Publish

- 0x.js@1.0.4
 - @0xproject/abi-gen@1.0.9
 - @0xproject/assert@1.0.9
 - @0xproject/base-contract@2.0.3
 - @0xproject/connect@2.0.2
 - @0xproject/contract-wrappers@1.0.4
 - contracts@2.1.45
 - @0xproject/dev-utils@1.0.8
 - ethereum-types@1.0.7
 - @0xproject/fill-scenarios@1.0.3
 - @0xproject/forwarder-helper@1.0.4
 - @0xproject/json-schemas@1.0.2
 - @0xproject/metacoin@0.0.19
 - @0xproject/migrations@1.0.10
 - @0xproject/monorepo-scripts@1.0.9
 - @0xproject/order-utils@1.0.3
 - @0xproject/order-watcher@1.0.4
 - @0xproject/react-docs@1.0.9
 - @0xproject/react-shared@1.0.10
 - @0xproject/sol-compiler@1.1.3
 - @0xproject/sol-cov@2.1.3
 - @0xproject/sol-resolver@1.0.9
 - @0xproject/sra-report@1.0.9
 - @0xproject/sra-spec@1.0.2
 - @0xproject/subproviders@2.0.3
 - @0xproject/testnet-faucets@1.0.47
 - @0xproject/types@1.0.2
 - @0xproject/typescript-typings@2.0.1
 - @0xproject/utils@1.0.9
 - @0xproject/web3-wrapper@2.0.3
 - @0xproject/website@0.0.50

.circleci/config.yml

@@ -2,28 +2,258 @@ version: 2
 
 jobs:
   build:
+    resource_class: medium+
     docker:
-      - image: circleci/node:6.12
+      - image: circleci/node:9
     environment:
       CONTRACTS_COMMIT_HASH: '9ed05f5'
+    working_directory: ~/repo
     steps:
       - checkout
       - run: echo 'export PATH=$HOME/CIRCLE_PROJECT_REPONAME/node_modules/.bin:$PATH' >> $BASH_ENV
+      - restore_cache:
+          name: Restore Yarn Package Cache
+          keys:
+            - yarn-packages-{{ .Branch }}-{{ checksum "yarn.lock" }}
+            - yarn-packages-{{ .Branch }}
+            - yarn-packages-master
+            - yarn-packages-
+      - run:
+          name: install-yarn
+          command: sudo npm install --global yarn@1.9.4
       - run:
           name: yarn
-          command: yarn
+          command: yarn --frozen-lockfile install || yarn --frozen-lockfile install
       - save_cache:
-          key: dependency-cache-{{ checksum "package.json" }}
+          name: Save Yarn Package Cache
+          key: yarn-packages-{{ .Branch }}-{{ checksum "yarn.lock" }}
           paths:
-            - ~/.cache/yarn
-      - run: wget https://s3.amazonaws.com/testrpc-shapshots/${CONTRACTS_COMMIT_HASH}.zip
-      - run: unzip ${CONTRACTS_COMMIT_HASH}.zip -d testrpc_snapshot
-      - run: node ./node_modules/lerna/bin/lerna.js bootstrap
-      - run: yarn lerna:run build
-      - run:
-          name: testrpc
-          command: npm run testrpc -- --db testrpc_snapshot
-          background: true
-      - run: yarn lerna:run test:circleci
-      - run: yarn lerna:run lint
+            - node_modules/
+      - run: >
+            if [ -z "$(git diff --name-only development packages/website)" ]; then
+                yarn build --exclude website
+            else
+                yarn build
+            fi
+      - save_cache:
+          key: repo-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo
+  test-contracts-ganache:
+    docker:
+      - image: circleci/node:9
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn wsrun test:circleci contracts
+  test-contracts-geth:
+    docker:
+      - image: circleci/node:9
+      - image: albrow/0x-devnet
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      # HACK(albrow): we need to sleep 10 seconds to ensure the devnet is
+      # initialized
+      - run: sleep 10 && TEST_PROVIDER=geth yarn wsrun test contracts
+  test-publish:
+    resource_class: medium+
+    docker:
+      - image: circleci/node:9
+      - image: verdaccio/verdaccio
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn test:publish:circleci
+  test-doc-generation:
+    docker:
+      - image: circleci/node:9
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn test:generate_docs:circleci
+  test-rest:
+    docker:
+      - image: circleci/node:9
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn wsrun test:circleci @0xproject/abi-gen
+      - run: yarn wsrun test:circleci @0xproject/assert
+      - run: yarn wsrun test:circleci @0xproject/base-contract
+      - run: yarn wsrun test:circleci @0xproject/connect
+      - run: yarn wsrun test:circleci @0xproject/contract-wrappers
+      - run: yarn wsrun test:circleci @0xproject/dev-utils
+      - run: yarn wsrun test:circleci @0xproject/json-schemas
+      - run: yarn wsrun test:circleci @0xproject/metacoin
+      - run: yarn wsrun test:circleci @0xproject/order-utils
+      - run: yarn wsrun test:circleci @0xproject/order-watcher
+      - run: yarn wsrun test:circleci @0xproject/sol-compiler
+      - run: yarn wsrun test:circleci @0xproject/sol-cov
+      - run: yarn wsrun test:circleci @0xproject/sra-report
+      - run: yarn wsrun test:circleci @0xproject/subproviders
+      - run: yarn wsrun test:circleci @0xproject/web3-wrapper
+      - run: yarn wsrun test:circleci @0xproject/utils
+      - save_cache:
+          key: coverage-abi-gen-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/abi-gen/coverage/lcov.info
+      - save_cache:
+          key: coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/assert/coverage/lcov.info
+      - save_cache:
+          key: coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/base-contract/coverage/lcov.info
+      - save_cache:
+          key: coverage-connect-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/connect/coverage/lcov.info
+      - save_cache:
+          key: coverage-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/contract-wrappers/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-metacoin-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/metacoin/coverage/lcov.info
+      - save_cache:
+          key: coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/order-utils/coverage/lcov.info
+      - save_cache:
+          key: coverage-order-watcher-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/order-watcher/coverage/lcov.info
+      - save_cache:
+          key: coverage-sol-compiler-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/sol-compiler/coverage/lcov.info
+      - save_cache:
+          key: coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/sol-cov/coverage/lcov.info
+      - save_cache:
+          key: coverage-sra-report-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/sra-report/coverage/lcov.info
+      - save_cache:
+          key: coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/subproviders/coverage/lcov.info
+      - save_cache:
+          key: coverage-web3-wrapper-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/repo/packages/web3-wrapper/coverage/lcov.info
+  static-tests:
+    working_directory: ~/repo
+    docker:
+      - image: circleci/node:9
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
       - run: yarn prettier:ci
+      - run: yarn lerna run lint
+  submit-coverage:
+    docker:
+      - image: circleci/node:9
+    working_directory: ~/repo
+    steps:
+      - restore_cache:
+          keys:
+            - repo-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-abi-gen-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-assert-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-base-contract-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-connect-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-contract-wrappers-{{ .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-metacoin-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-order-utils-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-order-watcher-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-sol-compiler-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-sra-report-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-web3-wrapper-{{ .Environment.CIRCLE_SHA1 }}
+      - restore_cache:
+          keys:
+            - coverage-contracts-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn report_coverage
+workflows:
+  version: 2
+  main:
+    jobs:
+      - build
+      - test-contracts-ganache:
+          requires:
+            - build
+      - test-contracts-geth:
+          requires:
+            - build
+      - test-rest:
+          requires:
+            - build
+      - static-tests:
+          requires:
+            - build
+      - test-publish:
+          requires:
+            - build
+      - test-doc-generation:
+          requires:
+            - build
+      - submit-coverage:
+          requires:
+            - test-rest

.editorconfig

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

.gitattributes

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

.gitignore

@@ -41,6 +41,7 @@ typings/
 
 # Optional npm cache directory
 .npm
+.npmrc
 
 # Optional eslint cache
 .eslintcache
@@ -67,7 +68,43 @@ generated_docs/
 
 TODO.md
 
-packages/website/public/bundle*
+# VSCode file
+.vscode
 
-# generated binaries
-bin/
+packages/website/public/bundle*
+packages/react-docs/example/public/bundle*
+
+# server cli
+packages/testnet-faucets/server/
+
+# generated contract artifacts/
+packages/sol-cov/test/fixtures/artifacts/
+packages/metacoin/artifacts/
+packages/order-watcher/test/artifacts/
+packages/contract-wrappers/test/artifacts/
+packages/contract-wrappers/src/artifacts/
+packages/order-watcher/src/artifacts/
+packages/0x.js/src/artifacts/
+packages/order-utils/src/artifacts/
+
+# unstable generated contract artifacts:
+packages/migrations/artifacts/development/
+
+# generated contract watcher
+packages/0x.js/src/generated_contract_wrappers/
+packages/contracts/generated_contract_wrappers/
+packages/contract-wrappers/src/contract_wrappers/generated/
+packages/metacoin/src/contract_wrappers
+packages/fill-scenarios/src/generated_contract_wrappers/
+packages/order-watcher/src/generated_contract_wrappers/
+packages/order-utils/src/generated_contract_wrappers/
+packages/migrations/src/1.0.0/contract_wrappers
+packages/migrations/src/2.0.0-testnet/contract_wrappers
+packages/migrations/src/2.0.0/contract_wrappers
+packages/migrations/src/development/contract_wrappers
+
+# solc-bin in sol-compiler
+packages/sol-compiler/solc_bin/
+
+# Monorepo scripts
+packages/*/scripts/

.npmignore

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

.prettierignore

@@ -1,4 +1,27 @@
 lib
-generated
 .nyc_output
-/packages/contracts/build/contracts
+/packages/contract-wrappers/src/contract_wrappers/generated/
+/packages/metacoin/src/contract_wrappers
+/packages/0x.js/src/generated_contract_wrappers/
+/packages/contracts/generated_contract_wrappers/
+/packages/fill-scenarios/src/generated_contract_wrappers/
+/packages/order-watcher/src/generated_contract_wrappers/
+/packages/order-utils/src/generated_contract_wrappers/
+/packages/migrations/src/1.0.0/contract_wrappers
+/packages/migrations/src/2.0.0-testnet/contract_wrappers
+/packages/migrations/src/2.0.0/contract_wrappers
+/packages/0x.js/src/artifacts
+/packages/contracts/src/artifacts
+/packages/contract-wrappers/src/artifacts
+/packages/order-watcher/src/artifacts
+/packages/metacoin/artifacts
+/packages/sra-spec/public/
+/packages/contract-wrappers/test/artifacts
+/packages/order-watcher/test/artifacts
+/packages/migrations/artifacts/1.0.0
+/packages/migrations/artifacts/2.0.0-testnet
+/packages/migrations/artifacts/2.0.0
+/packages/migrations/artifacts/development
+package.json
+scripts/postpublish_utils.js
+packages/sol-cov/test/fixtures/artifacts

CODEOWNERS

@@ -0,0 +1,8 @@
+# See https://help.github.com/articles/about-codeowners/
+# for more info about CODEOWNERS file
+
+# It uses the same pattern rule for gitignore file
+# https://git-scm.com/docs/gitignore#_pattern_format
+
+# Website
+packages/website/  @BMillman19 @fragosti

CODE_OF_CONDUCT.md

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

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
 
@@ -21,9 +21,21 @@ If you're adding a new public function/member, make sure you document it with Ja
 
 If the sub-package you are modifying has a `CHANGELOG.md` file, make sure to add an entry in it for the change made to the package. For published packages, only changes that modify the public interface or behavior of the package need a CHANGELOG entry.
 
+#### Enabling code coverage checks on your fork
+
+If you simply fork the repo and then create a PR sourced from it, your PR will fail its test coverage check. This is because the 0x CircleCI configuration sets the `COVERALLS_REPO_TOKEN` environment variable to the token for 0xProject/0x-monorepo, but when running the check against your fork the token needs to match the repo that is your fork, rather than the 0x repo.
+
+To facilitate this check, after creating your fork, but before creating the branch for your PR, do the following:
+
+1.  Log in to [coveralls.io](https://coveralls.io/), go to Add Repos, and enable your fork. Then go to the settings for that repo, and copy the Repo Token identifier.
+2.  Log in to [CircleCI](https://circleci.com/login), go to Add Projects, click the Set Up Project button corresponding to your fork, and then click Start Building. (Aside from step 3 below, no actual set up is needed, since it will use the `.circleci/config.yml` file in 0x-monorepo, so you can ignore all of the instruction/explanation given on the page with the Start Building button.)
+3.  In CircleCI, configure your project to add an Environment Variable, with name `COVERALLS_REPO_TOKEN`, and for the value paste in the Repo Token you copied in step 1.
+
+Now, when you push to your branch, CircleCI will automatically run all of the checks in your own instance, and the coverage check will work since it has the proper Repo Token, and the PR will magically refer to your own checks rather than running them in the 0x CircleCI instance.
+
 ### 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 +43,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.
 

ISSUE_TEMPLATE.md

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

PULL_REQUEST_TEMPLATE.md

@@ -1,3 +1,27 @@
-This PR:
+## Description
 
-\*
+<!--- Describe your changes in detail -->
+
+## Testing instructions
+
+<!--- Please describe how reviewers can test your changes -->
+
+## Types of changes
+
+<!--- What types of changes does your code introduce? Uncomment all the bullets that apply: -->
+
+<!-- * Bug fix (non-breaking change which fixes an issue) -->
+
+<!-- * New feature (non-breaking change which adds functionality) -->
+
+<!-- * Breaking change (fix or feature that would cause existing functionality to change) -->
+
+## Checklist:
+
+<!--- The following points should be used to indicate the progress of your PR.  Put an `x` in all the boxes that apply right now, and come back over time and check them off as you make progress.  If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+
+*   [ ] Prefix PR title with `[WIP]` if necessary.
+*   [ ] Prefix PR title with bracketed package name(s) corresponding to the changed package(s). For example: `[sol-cov] Fixed bug`.
+*   [ ] Add tests to cover changes as needed.
+*   [ ] Update documentation as needed.
+*   [ ] Add new entries to the relevant CHANGELOG.jsons.

README.md

@@ -4,64 +4,86 @@
 
 [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/
+If you're developing on 0x now or are interested in using 0x infrastructure in the future, please join our [developer mailing list][dev-mailing-list-url] for updates.
+
+[website-url]: https://0xproject.com
 [whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
+[dev-mailing-list-url]: http://eepurl.com/dx4cPf
 
-[![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          |
-| [`@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/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/sol-compiler`](/packages/sol-compiler)             | [![npm](https://img.shields.io/npm/v/@0xproject/sol-compiler.svg)](https://www.npmjs.com/package/@0xproject/sol-compiler)             | A thin wrapper around Solc.js that outputs artifacts, resolves imports, only re-compiles when needed, and other niceties. |
+| [`@0xproject/dev-utils`](/packages/dev-utils)                   | [![npm](https://img.shields.io/npm/v/@0xproject/dev-utils.svg)](https://www.npmjs.com/package/@0xproject/dev-utils)                   | Dev utils to be shared across 0x projects and packages                                                                    |
+| [`@0xproject/json-schemas`](/packages/json-schemas)             | [![npm](https://img.shields.io/npm/v/@0xproject/json-schemas.svg)](https://www.npmjs.com/package/@0xproject/json-schemas)             | 0x-related json schemas                                                                                                   |
+| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts)     | [![npm](https://img.shields.io/npm/v/@0xproject/monorepo-scripts.svg)](https://www.npmjs.com/package/@0xproject/monorepo-scripts)     | Monorepo scripts                                                                                                          |
+| [`@0xproject/react-docs`](/packages/react-docs)                 | [![npm](https://img.shields.io/npm/v/@0xproject/react-docs.svg)](https://www.npmjs.com/package/@0xproject/react-docs)                 | React documentation component for rendering TypeDoc & Doxity generated JSON                                               |
+| [`@0xproject/react-shared`](/packages/react-shared)             | [![npm](https://img.shields.io/npm/v/@0xproject/react-shared.svg)](https://www.npmjs.com/package/@0xproject/react-shared)             | 0x shared react components                                                                                                |
+| [`@0xproject/sra-spec`](/packages/sra-spec)                     | [![npm](https://img.shields.io/npm/v/@0xproject/sra-spec.svg)](https://www.npmjs.com/package/@0xproject/sra-spec)                     | OpenAPI specification for the standard relayer API                                                                        |
+| [`@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/kovan_faucets`](/packages/kovan-faucets)       | A faucet micro-service that dispenses test ERC20 tokens or Ether |
-| [`@0xproject/monorepo-scripts`](/packages/monorepo-scripts) | Shared monorepo scripts                                          |
-| [`@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)
+*   [Sol Compiler](https://0xproject.com/docs/sol-compiler)
+*   [Web3-wrapper](https://0xproject.com/docs/web3-wrapper)
+*   [JSON-schemas](https://0xproject.com/docs/json-schemas)
+*   [Sol-cov](https://0xproject.com/docs/sol-cov)
+*   [Standard Relayer API](https://github.com/0xProject/standard-relayer-api/blob/master/README.md)
+
+Node version >= 6.12 is required.
+
+Most of the packages require additional typings for external dependencies.
+You can include those by prepending the `@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
 
-If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
-
-```bash
-yarn config set workspaces-experimental true
-```
+Make sure you are using Yarn v1.9.4. To install using brew:
 
 Then install dependencies
 
@@ -71,40 +93,87 @@ yarn install
 
 ### Build
 
-Build all packages
+To build all packages:
 
 ```bash
-yarn lerna:run build
+yarn build
+```
+
+To build a specific package:
+
+```bash
+PKG=@0xproject/web3-wrapper yarn build
+```
+
+### Watch
+
+To re-build all packages on change:
+
+```bash
+yarn watch
+```
+
+To watch a specific package and all it's dependent packages:
+
+```bash
+PKG=[NPM_PACKAGE_NAME] yarn watch
+
+e.g
+PKG=@0xproject/web3-wrapper yarn watch
+```
+
+### Clean
+
+Clean all packages:
+
+```bash
+yarn clean
+```
+
+Clean a specific package
+
+```bash
+PKG=0x.js yarn clean
+```
+
+### Rebuild
+
+To re-build (clean & build) all packages:
+
+```bash
+yarn rebuild
+```
+
+To re-build (clean & build) a specific package & it's deps:
+
+```bash
+PKG=0x.js yarn rebuild
 ```
 
 ### Lint
 
-Lint all packages
+Lint all packages:
 
 ```bash
-yarn lerna:run lint
+yarn lint
+```
+
+Lint a specific package:
+
+```bash
+PKG=0x.js yarn lint
 ```
 
 ### Run Tests
 
-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)
+Run all tests:
 
 ```bash
-yarn testrpc
+yarn test
 ```
 
-Then in your main terminal run
-
-```
-cd packages/contracts
-yarn migrate
-cd ..
-```
-
-And finally from the root project directory run
+Run a specific package's test:
 
 ```bash
-yarn lerna:run test
+PKG=@0xproject/web3-wrapper yarn test
 ```

lerna.json

@@ -1,7 +1,12 @@
 {
-    "lerna": "2.5.1",
+    "lerna": "3.0.0-beta.23",
     "packages": ["packages/*"],
     "version": "independent",
+    "command": {
+        "publish": {
+            "ignoreChanges": ["test/**/*", "*.md", "scripts", "lib", "tslint.json", "tsconfig.json"]
+        }
+    },
     "npmClient": "yarn",
     "useWorkspaces": true
 }

package.json

@@ -1,26 +1,61 @@
 {
     "private": true,
-    "name": "0x.js",
-    "workspaces": ["packages/*"],
+    "name": "0x-monorepo",
+    "engines": {
+        "node": ">=6.12"
+    },
+    "workspaces": [
+        "packages/*"
+    ],
     "scripts": {
-        "testrpc": "testrpc -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
-        "prettier": "prettier --write '**/*.{ts,tsx,json,md}'",
-        "prettier:ci": "prettier --list-different '**/*.{ts,tsx,json,md}'",
-        "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/"
+        "ganache": "ganache-cli -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
+        "prettier": "prettier --write '**/*.{ts,tsx,json,md}' --config .prettierrc",
+        "prettier:ci": "prettier --list-different '**/*.{ts,tsx,json,md}' --config .prettierrc",
+        "report_coverage": "lcov-result-merger 'packages/*/coverage/lcov.info' | coveralls",
+        "test:installation": "node ./packages/monorepo-scripts/lib/test_installation.js",
+        "test:installation:local": "IS_LOCAL_PUBLISH=true node ./packages/monorepo-scripts/lib/test_installation.js",
+        "test:publish:circleci:comment": "HACK(albrow) We need an automated way to login to npm and echo+sleep piped to stdin was the only way I could find to do it.",
+        "test:publish:circleci": "yarn npm-cli-login -u test -p test -e test@example.com -r http://localhost:4873 && IS_LOCAL_PUBLISH=true run-s script:publish test:installation:local",
+        "run:publish": "run-s install:all build:monorepo_scripts script:prepublish_checks rebuild:no_website script:publish",
+        "run:publish:local": "IS_LOCAL_PUBLISH=true yarn run:publish",
+        "script:prepublish_checks": "node ./packages/monorepo-scripts/lib/prepublish_checks.js",
+        "script:publish": "node ./packages/monorepo-scripts/lib/publish.js",
+        "install:all": "yarn install",
+        "wsrun": "wsrun",
+        "lerna": "lerna",
+        "build": "wsrun build $PKG --fast-exit -r --stages",
+        "build:no_website": "wsrun build $PKG --fast-exit -r --stages --exclude @0xproject/website",
+        "build:monorepo_scripts": "PKG=@0xproject/monorepo-scripts yarn build",
+        "build:ts": "tsc -b",
+        "watch:ts": "tsc -b -w",
+        "clean": "wsrun clean $PKG --fast-exit -r --parallel",
+        "remove_node_modules": "lerna clean --yes; rm -rf node_modules",
+        "rebuild": "run-s clean build",
+        "rebuild:no_website": "run-s clean build:no_website",
+        "test": "wsrun test $PKG --fast-exit --serial --exclude-missing",
+        "generate_doc": "node ./packages/monorepo-scripts/lib/doc_generate_and_upload.js",
+        "test:generate_docs:circleci": "for i in ${npm_package_config_packagesWithDocPages}; do yarn generate_doc --package $i --shouldUpload false --isStaging true || break -1; done;",
+        "lint": "wsrun lint $PKG --fast-exit --parallel --exclude-missing",
+        "comment:postinstall": "HACK: For some reason `yarn` is not setting up symlinks properly for order-utils. We temporarily set them manually. Remove this after V2 refactor is complete."
     },
     "config": {
-        "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
+        "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic",
+        "packagesWithDocPages": "0x.js connect json-schemas subproviders web3-wrapper contract-wrappers order-utils order-watcher sol-compiler sol-cov ethereum-types"
     },
     "devDependencies": {
-        "@0xproject/utils": "^0.1.0",
+        "@0x-lerna-fork/lerna": "3.0.0-beta.25",
         "async-child-process": "^1.1.1",
-        "ethereumjs-testrpc": "6.0.3",
-        "lerna": "^2.5.1",
-        "prettier": "1.9.2",
-        "publish-release": "0xproject/publish-release",
-        "semver-sort": "^0.0.4"
+        "coveralls": "^3.0.0",
+        "ganache-cli": "6.1.3",
+        "lcov-result-merger": "^3.0.0",
+        "npm-cli-login": "^0.0.10",
+        "npm-run-all": "^4.1.2",
+        "prettier": "^1.11.1",
+        "source-map-support": "^0.5.6",
+        "typescript": "3.0.1",
+        "wsrun": "^2.2.0"
+    },
+    "resolutions": {
+        "ethers": "0xproject/ethers.js#eip-838-reasons"
     }
 }

packages/0x.js/.npmignore

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

packages/0x.js/CHANGELOG.md

@@ -1,15 +1,208 @@
-# CHANGELOG
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
 
-## v0.29.1 - _January 11, 2018_
+CHANGELOG
+
+## v1.0.4 - _September 21, 2018_
+
+    * Dependencies updated
+
+## v1.0.3 - _September 19, 2018_
+
+    * Drastically reduce the bundle size by removing unused parts of included contract artifacts.
+
+## v1.0.2 - _September 18, 2018_
+
+    * Add ZRX & WETH mainnet contract addresses into the included artifacts
+
+## v1.0.1 - _September 5, 2018_
+
+    * Dependencies updated
+
+## v1.0.1-rc.6 - _August 27, 2018_
+
+    * Fix missing `BlockParamLiteral` type import issue
+
+## v1.0.1-rc.5 - _Invalid date_
+
+    * Fix `main` and `types` package.json entries so that they point to the new location of index.d.ts and index.js
+
+## v1.0.1-rc.4 - _August 24, 2018_
+
+    * Re-organize the exported interface of 0x.js. Remove the `ZeroEx` class, and instead export the same exports as `0x.js`'s sub-packages: `@0xproject/contract-wrappers`, `@0xproject/order-utils` and `@0xproject/order-watcher` (#963)
+
+## v1.0.1-rc.3 - _August 14, 2018_
+
+    * Dependencies updated
+    * Update ecSignOrderHashAsync to return the signature as a string for immediate use in contracts (#914)
+
+## v1.0.1-rc.2 - _July 26, 2018_
+
+    * Fixed bug caused by importing non-existent dep
+
+## v1.0.1-rc.1 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.0 - _July 23, 2018_
+
+    * Dependencies updated
+
+## v1.0.0-rc.2 - _July 20, 2018_
+
+    * Remove `zeroEx.assetData`  and instead re-export it's static functions directly off `ZeroEx`
+
+## v1.0.0-rc.1 - _July 20, 2018_
+
+    * Remove tokenRegistry wrapper (#863)
+    * Rename `zeroEx.token` to `zeroEx.erc20Token`, and add `zeroEx.erc721Token` (#863)
+    * Rename `zeroEx.proxy` to `zeroEx.erc20Proxy` and add `zeroEx.erc721Proxy` (#863)
+    * Refactored `ZeroEx.isValidSignature` to `zeroEx.isValidSignatureAsync`. It is now async so that it can verify contract-dependent signature types (#863)
+    * Refactored `signOrderHashAsync` to `ecSignOrderHashAsync`. There are now many non-ECSignature ways to sign orders too. (#863)
+    * Removed `createOrderWatcherAsync` method. Will be added back once OrderWatcher is refactored for V2 (#863)
+    * 0x.js exports renamed contract events and event arg types (#863)
+    * Export `ZeroEx.assetData` with methods to decode/encode assetData fields found in 0x orders (#884)
+
+## v0.38.6 - _July 18, 2018_
+
+    * Dependencies updated
+
+## v0.38.5 - _July 9, 2018_
+
+    * Dependencies updated
+
+## v0.38.4 - _June 19, 2018_
+
+    * Dependencies updated
+
+## v0.38.3 - _May 29, 2018_
+
+    * Dependencies updated
+
+## v0.38.2 - _May 29, 2018_
+
+    * Dependencies updated
+
+## v0.38.1 - _May 29, 2018_
+
+    * Dependencies updated
+
+## v0.38.0 - _May 22, 2018_
+
+    * Renamed createOrderStateWatcher to createOrderWatcherAsync since it is now async (#579)
+    * Renamed ZeroExError to ContractWrappersErrors since they now lives in the @0xproject/contract-wrappers subpackage (#579)
+
+## v0.37.2 - _May 5, 2018_
+
+    * Dependencies updated
+
+## v0.37.1 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.37.0 - _May 4, 2018_
+
+    * Fixed expiration watcher comparator to handle orders with equal expiration times (#526)
+    * Update Web3 Provider Engine to 14.0.4 (#555)
+    * Add `zeroEx.getProvider()` (#559)
+    * Move `ZeroExError.InvalidSignature` to `@0xproject/order-utils` `OrderError.InvalidSignature` (#559)
+
+## v0.36.3 - _April 18, 2018_
+
+    * Move @0xproject/migrations to devDependencies
+
+## v0.36.2 - _April 18, 2018_
+
+    * Dependencies updated
+
+## v0.36.1 - _April 18, 2018_
+
+    * Internal changes and refactoring
+    * Fix redundant expired order removal bug (#527)
+
+## v0.36.0 - _April 11, 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 17, 2018_
+
+    * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
+    * Consolidate `Order`, `SignedOrder`, and `ECSignature` into the `@0xproject/types` package (#456)
+
+## v0.33.1 - _March 7, 2018_
+
+    * Add missing EthersJs typescript typings as dependency
+
+## v0.33.0 - _March 3, 2018_
+
+    * Validate and lowercase all addresses in public methods (#373)
+    * Improve validation to force passing contract addresses on private networks (#385)
+    * Change `LogErrorContractEventArgs.errorId` type from `BigNumber` to `number` (#413)
+    * Rename all public `_unsubscribeAll` methods to `unsubscribeAll` (#415)
+    * Move web3 typings from devDep to dep since cannot use this package without it (#429)
+
+## v0.32.2 - _February 8, 2018_
+
+    * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
+
+## v0.32.1 - _February 6, 2018_
+
+    * Reorganized `BlockParamLiteral` export into `@0xproject/types` package (#355)
+    * Now using `abi-gen` package to generate ContractEventArgs types (#371)
+
+## v0.32.0 - _February 4, 2018_
+
+    * Add `zeroEx.etherToken.getContractAddressIfExists` (#350)
+    * Fixed the bug causing order watcher to throw if there is an event with the same signature but different indexed fields (#366)
+
+## v0.31.1 - _January 31, 2018_
+
+    * Fix the bug causing order watcher to throw if makerToken === zrx (#357)
+
+## v0.31.0 - _January 29, 2018_
+
+    * Add the `shouldAddPersonalMessagePrefix` parameter to `signOrderHashAsync` so that the caller can decide on whether to add the personalMessage prefix before relaying the request to the signer. Parity Signer, Ledger and TestRPC add the prefix themselves, Metamask expects it to have already been added. (#349)
+
+## v0.30.2 - _January 28, 2018_
+
+    * Add Rinkeby testnet addresses to artifacts  (#337)
+    * Move @0xproject/types to dependencies from devDependencies fixing missing type errors
+
+## v0.30.1 - _January 23, 2018_
+
+    * Fix a bug allowing negative fill values  (#212)
+    * Fix a bug that made it impossible to pass a custom ZRX address  (#341)
+
+## v0.30.0 - _January 16, 2018_
+
+    * Add an error parameter to the order watcher callback (#312)
+    * Fix a bug making it impossible to catch some errors from awaitTransactionMinedAsync (#312)
+    * Fix a bug in fillOrdersUpTo validation making it impossible to fill up to if user doesn't have enough balance to fully fill all the orders (#321)
+
+## v0.29.1 - _January 10, 2018_
 
     * Fixed bignumber config issue #301 (#305)
 
-## v0.29.0 - _December 28, 2017_
+## v0.29.0 - _December 27, 2017_
 
     * Assert baseUnit amount supplied to `toUnitAmount` is integer amount. (#287)
     * `toBaseUnitAmount` throws if amount supplied has too many decimals (#287)
 
-## v0.28.0 - _December 20, 2017_
+## v0.28.0 - _December 19, 2017_
 
     * Add `etherTokenAddress` arg to `depositAsync` and `withdrawAsync` methods on `zeroEx.etherToken` (#267)
     * Removed accidentally included `unsubscribeAll` method from `zeroEx.proxy`, `zeroEx.etherToken` and `zeroEx.tokenRegistry` (#267)
@@ -21,11 +214,11 @@
     * Support `Deposit` and `Withdraw` events on etherToken (#277)
     * Improve the error message when taker is not a string (#278)
 
-## v0.27.1 - _November 28, 2017_
+## v0.27.1 - _November 27, 2017_
 
     * Export `TransactionOpts` type
 
-## v0.27.0 - _November 28, 2017_
+## v0.27.0 - _November 27, 2017_
 
     * Make `ZeroExConfig` required parameter of `ZeroEx` constructor (#233)
     * Add a required property `networkId` to `ZeroExConfig` (#233)
@@ -37,149 +230,149 @@
     * All transaction sending methods now call `estimateGas` if no gas amount was supplied (#235)
     * Modify order validation methods to validate against the `latest` block, not against the `pending` block (#236)
 
-## v0.26.0 - _November 21, 2017_
+## v0.26.0 - _November 20, 2017_
 
     * Add post-formatter for logs converting `blockNumber`, `logIndex`, `transactionIndex` from hexes to numbers (#231)
     * Remove support for Async callback types when used in Subscribe functions (#222)
     * In OrderWatcher subscribe to ZRX Token Transfer and Approval events when maker token is different (#225)
 
-## v0.25.1 - _November 13, 2017_
+## v0.25.1 - _November 12, 2017_
 
     * Standardise on Cancelled over Canceled (#217)
     * Add missing `DecodedLogEvent` type to exported types (#205)
     * Normalized the transactionReceipt status to be `null|0|1`, 1 meaning transaction execution successful, 0 unsuccessful and `null` if it is a pre-byzantinium transaction. (#200)
 
-## v0.23.0 - _November 12, 2017_
+## v0.23.0 - _November 11, 2017_
 
     * Fixed unhandled promise rejection error in subscribe methods (#209)
     * Subscribe callbacks now receive an error object as their first argument
 
-## v0.22.6 - _November 10, 2017_
+## v0.22.6 - _November 9, 2017_
 
     * Add a timeout parameter to transaction awaiting (#206)
 
-## v0.22.5 - _November 7, 2017_
+## v0.22.5 - _November 6, 2017_
 
     * Re-publish v0.22.4 to fix publishing issue
 
-## v0.22.4 - _October 25, 2017_
+## v0.22.4 - _October 24, 2017_
 
     * Upgraded bignumber.js to a new version that ships with native typings
 
-## v0.22.3 - _October 25, 2017_
+## v0.22.3 - _October 24, 2017_
 
     * Fixed an issue with new version of testrpc and unlimited proxy allowance (#199)
 
-## v0.22.2 - _October 24, 2017_
+## v0.22.2 - _October 23, 2017_
 
     * Fixed rounding of maker fill amount and incorrect validation of partial fees (#197)
 
-## v0.22.0 - _October 16, 2017_
+## v0.22.0 - _October 15, 2017_
 
     * Started using `OrderFillRequest` interface instead of `OrderFillOrKillRequest` interface for `zeroEx.exchange.batchFillOrKill` (#187)
     * Removed `OrderFillOrKillRequest` (#187)
 
-## v0.21.4 - _October 13, 2017_
+## v0.21.4 - _October 12, 2017_
 
     * Made 0x.js more type-safe by making `getLogsAsync` and `subscribe/subscribeAsync` generics parametrized with arg type (#194)
 
-## v0.21.3 - _October 12, 2017_
+## v0.21.3 - _October 11, 2017_
 
     * Fixed a bug causing order fills to throw `INSUFFICIENT_TAKER_ALLOWANCE` (#193)
 
-## v0.21.2 - _October 11, 2017_
+## v0.21.2 - _October 10, 2017_
 
     * Exported `ContractEventArg` as a public type (#190)
 
-## v0.21.1 - _October 11, 2017_
+## v0.21.1 - _October 10, 2017_
 
     * Fixed a bug in subscriptions (#189)
 
-## v0.21.0 - _October 10, 2017_
+## v0.21.0 - _October 9, 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_
+## v0.20.0 - _October 4, 2017_
 
     * Add `zeroEx.token.getLogsAsync` (#178)
     * Add `zeroEx.exchange.getLogsAsync` (#178)
     * Fixed fees validation when one of the tokens transferred is ZRX (#181)
 
-## v0.19.0 - _September 29, 2017_
+## v0.19.0 - _September 28, 2017_
 
     * Made order validation optional  (#172)
     * Added Ropsten testnet support (#173)
     * Fixed a bug causing awaitTransactionMinedAsync to DDos backend nodes (#175)
 
-## v0.18.0 - _September 26, 2017_
+## v0.18.0 - _September 25, 2017_
 
     * Added `zeroEx.exchange.validateOrderFillableOrThrowAsync` to simplify orderbook pruning (#170)
 
-## v0.17.0 - _September 26, 2017_
+## v0.17.0 - _September 25, 2017_
 
     * Made `zeroEx.exchange.getZRXTokenAddressAsync` public (#171)
 
-## v0.16.0 - _September 20, 2017_
+## v0.16.0 - _September 19, 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_
+## v0.15.0 - _September 7, 2017_
 
     * Added the ability to specify a historical `blockNumber` at which to query the blockchain's state when calling a token or exchange method (#161)
 
-## v0.14.2 - _September 7, 2017_
+## v0.14.2 - _September 6, 2017_
 
     * Fixed an issue with bignumber.js types not found (#160)
 
-## v0.14.1 - _September 7, 2017_
+## v0.14.1 - _September 6, 2017_
 
     * Fixed an issue with Artifact type not found (#159)
 
-## v0.14.0 - _September 6, 2017_
+## v0.14.0 - _September 5, 2017_
 
     * Added `zeroEx.exchange.throwLogErrorsAsErrors` method to public interface (#157)
     * Fixed an issue with overlapping async intervals in `zeroEx.awaitTransactionMinedAsync` (#157)
     * Fixed an issue with log decoder returning `BigNumber`s as `strings` (#157)
 
-## v0.13.0 - _September 6, 2017_
+## v0.13.0 - _September 5, 2017_
 
     * Made all the functions submitting transactions to the network to immediately return transaction hash (#151)
     * Added `zeroEx.awaitTransactionMinedAsync` (#151)
     * Added `TransactionReceiptWithDecodedLogs`, `LogWithDecodedArgs`, `DecodedLogArgs` to public types (#151)
     * Added signature validation to `validateFillOrderThrowIfInvalidAsync` (#152)
 
-## v0.12.1 - _September 2, 2017_
+## v0.12.1 - _September 1, 2017_
 
     * Added the support for web3@1.x.x provider (#142)
     * Added the optional `zeroExConfig`  parameter to the constructor of `ZeroEx` (#139)
     * Added the ability to specify `gasPrice` when instantiating `ZeroEx` (#139)
 
-## v0.11.0 - _August 24, 2017_
+## v0.11.0 - _August 23, 2017_
 
     * Added `zeroEx.token.setUnlimitedProxyAllowanceAsync` (#137)
     * Added `zeroEx.token.setUnlimitedAllowanceAsync` (#137)
     * Added `zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS` (#137)
 
-## v0.10.4 - _Aug 24, 2017_
+## v0.10.4 - _August 23, 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 23, 2017_
 
     * Added `zeroEx.exchange.validateFillOrderThrowIfInvalidAsync` (#128)
     * Added `zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync` (#128)
@@ -194,20 +387,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 21, 2017_
 
     * Update contract artifacts to include latest Kovan and Mainnet deploys (#118)
 
-## v0.9.2 - _Aug 21, 2017_
+## v0.9.2 - _August 20, 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 15, 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 25, 2017_
 
     * Migrated to the new version of smart contracts (#101)
     * Removed the ability to call methods on multiple authorized Exchange smart contracts (#106)
@@ -218,48 +411,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 3, 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 25, 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 21, 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 20, 2017_
 
     * Reduced bundle size
     * Improved documentation
 
-## v0.6.1 - _Jun. 19, 2017_
+## v0.6.1 - _June 18, 2017_
 
     * Improved documentation
 
-## v0.6.0 - _Jun. 19, 2017_
+## v0.6.0 - _June 18, 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 14, 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 14, 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. It is a high level package which combines a number of underlying packages such as order-utils and order-watcher.
+
+### 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.
@@ -15,14 +19,29 @@ npm install 0x.js --save
 **Import**
 
 ```javascript
-import { ZeroEx } from '0x.js';
+import {
+    assetDataUtils,
+    BigNumber,
+    ContractWrappers,
+    generatePseudoRandomSalt,
+    orderHashUtils,
+    signatureUtils,
+} 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 +49,54 @@ 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 0x 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
+
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
+```bash
+PKG=0x.js yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=0x.js yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```
+
+### Run Tests
+
+```bash
+yarn test
+```

packages/0x.js/contract_templates/contract.mustache

@@ -1,25 +0,0 @@
-/**
- * This file is auto-generated using abi-gen. Don't edit directly.
- * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates.
- */
-// tslint:disable-next-line:no-unused-variable
-import { TxData, TxDataPayable } from '@0xproject/types';
-import { BigNumber, classUtils, promisify } from '@0xproject/utils';
-import * as Web3 from 'web3';
-
-import {BaseContract} from './base_contract';
-
-export class {{contractName}}Contract extends BaseContract {
-{{#each methods}}
-    {{#this.constant}}
-    {{> call contractName=../contractName}}
-    {{/this.constant}}
-    {{^this.constant}}
-    {{> tx contractName=../contractName}}
-    {{/this.constant}}
-{{/each}}
-    constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial<TxData>) {
-        super(web3ContractInstance, defaults);
-        classUtils.bindAll(this, ['web3ContractInstance', 'defaults']);
-    }
-} // tslint:disable:max-file-line-count

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

@@ -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/params.mustache

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

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

@@ -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.mustache

@@ -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.mustache

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

packages/0x.js/package.json

@@ -1,6 +1,9 @@
 {
     "name": "0x.js",
-    "version": "0.29.2",
+    "version": "1.0.4",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "A javascript library for interacting with the 0x protocol",
     "keywords": [
         "0x.js",
@@ -9,95 +12,83 @@
         "tokens",
         "exchange"
     ],
-    "main": "lib/src/index.js",
-    "types": "lib/src/index.d.ts",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
     "scripts": {
-        "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 --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --templates contract_templates --output src/contract_wrappers/generated",
-        "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'",
-        "test:circleci": "run-s test:coverage report_test_coverage && if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi",
-        "test": "run-s clean test:commonjs",
-        "test:umd": "./scripts/test_umd.sh",
-        "test:coverage": "nyc npm run test --all",
-        "report_test_coverage": "nyc report --reporter=text-lcov | coveralls",
-        "update_contracts": "for i in ${npm_package_config_artifacts}; do copyfiles -u 4 ../contracts/build/contracts/$i.json ../0x.js/src/artifacts; done;",
-        "clean": "shx rm -rf _bundles lib test_temp",
-        "build:umd:dev": "webpack",
+        "build": "yarn build:all",
+        "build:all": "run-p build:umd:prod build:commonjs",
+        "lint": "tslint --project . --exclude **/src/generated_contract_wrappers/**/*",
+        "test:circleci": "run-s test:coverage",
+        "rebuild_and_test": "run-s build test",
+        "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
+        "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
+        "clean": "shx rm -rf _bundles lib test_temp src/generated_contract_wrappers generated_docs",
         "build:umd:prod": "NODE_ENV=production webpack",
-        "build:commonjs": "tsc && copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/artifacts;",
-        "test:commonjs": "run-s build:commonjs run_mocha",
-        "pretest:umd": "run-s clean build:umd:dev build:commonjs",
-        "substitute_umd_bundle": "shx mv _bundles/* lib/src",
-        "run_mocha": "mocha lib/test/**/*_test.js --timeout 10000 --bail --exit"
+        "build:commonjs": "tsc -b",
+        "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
     "config": {
-        "artifacts": "TokenTransferProxy Exchange TokenRegistry Token EtherToken"
+        "postpublish": {
+            "assets": [
+                "packages/0x.js/_bundles/index.js",
+                "packages/0x.js/_bundles/index.min.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.1.1",
-        "@0xproject/dev-utils": "^0.0.4",
-        "@0xproject/tslint-config": "^0.4.1",
-        "@0xproject/types": "^0.1.3",
-        "@types/bintrees": "^1.0.2",
-        "@types/jsonschema": "^1.1.1",
-        "@types/lodash": "^4.14.86",
+        "@0xproject/abi-gen": "^1.0.9",
+        "@0xproject/dev-utils": "^1.0.8",
+        "@0xproject/migrations": "^1.0.10",
+        "@0xproject/monorepo-scripts": "^1.0.9",
+        "@0xproject/tslint-config": "^1.0.7",
+        "@types/lodash": "4.14.104",
         "@types/mocha": "^2.2.42",
-        "@types/node": "^8.0.53",
+        "@types/node": "*",
         "@types/sinon": "^2.2.2",
-        "@types/uuid": "^3.4.2",
+        "@types/web3-provider-engine": "^14.0.0",
         "awesome-typescript-loader": "^3.1.3",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
-        "chai-as-promised-typescript-typings": "^0.0.3",
         "chai-bignumber": "^2.0.1",
-        "chai-typescript-typings": "^0.0.1",
-        "copyfiles": "^1.2.0",
-        "coveralls": "^3.0.0",
+        "copyfiles": "^2.0.0",
         "dirty-chai": "^2.0.1",
         "json-loader": "^0.5.4",
-        "mocha": "^4.0.1",
+        "make-promises-safe": "^1.1.0",
+        "mocha": "^4.1.0",
         "npm-run-all": "^4.1.2",
         "nyc": "^11.0.1",
         "opn-cli": "^3.1.0",
-        "request": "^2.81.0",
-        "request-promise-native": "^1.0.4",
         "shx": "^0.2.2",
         "sinon": "^4.0.0",
         "source-map-support": "^0.5.0",
-        "truffle-hdwallet-provider": "^0.0.3",
-        "tslint": "5.8.0",
-        "typedoc": "~0.8.0",
-        "typescript": "~2.6.1",
-        "web3-provider-engine": "^13.0.1",
-        "web3-typescript-typings": "^0.9.3",
+        "tslint": "5.11.0",
+        "typedoc": "0.12.0",
+        "typescript": "3.0.1",
+        "uglifyjs-webpack-plugin": "^1.3.0",
         "webpack": "^3.1.0"
     },
     "dependencies": {
-        "@0xproject/assert": "^0.0.10",
-        "@0xproject/json-schemas": "^0.7.2",
-        "@0xproject/utils": "^0.1.3",
-        "@0xproject/web3-wrapper": "^0.1.4",
-        "bintrees": "^1.0.2",
-        "bn.js": "^4.11.8",
-        "compare-versions": "^3.0.1",
-        "ethereumjs-abi": "^0.6.4",
-        "ethereumjs-blockstream": "^2.0.6",
-        "ethereumjs-util": "^5.1.1",
-        "find-versions": "^2.0.0",
-        "js-sha3": "^0.6.1",
-        "lodash": "^4.17.4",
-        "uuid": "^3.1.0",
-        "web3": "^0.20.0"
+        "@0xproject/assert": "^1.0.9",
+        "@0xproject/base-contract": "^2.0.3",
+        "@0xproject/contract-wrappers": "^1.0.4",
+        "@0xproject/order-utils": "^1.0.3",
+        "@0xproject/order-watcher": "^1.0.4",
+        "@0xproject/subproviders": "^2.0.3",
+        "@0xproject/types": "^1.0.2",
+        "@0xproject/typescript-typings": "^2.0.1",
+        "@0xproject/utils": "^1.0.9",
+        "@0xproject/web3-wrapper": "^2.0.3",
+        "ethereum-types": "^1.0.7",
+        "ethers": "3.0.22",
+        "lodash": "^4.17.5",
+        "web3-provider-engine": "14.0.6"
+    },
+    "publishConfig": {
+        "access": "public"
     }
 }

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

@@ -1,44 +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.publishReleaseNotes(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/scripts/test_umd.sh

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

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

@@ -1,340 +0,0 @@
-import { schemas, SchemaValidator } from '@0xproject/json-schemas';
-import { BigNumber, intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as ethUtil from 'ethereumjs-util';
-import * as _ from 'lodash';
-
-import { artifacts } from './artifacts';
-import { EtherTokenWrapper } from './contract_wrappers/ether_token_wrapper';
-import { ExchangeWrapper } from './contract_wrappers/exchange_wrapper';
-import { TokenRegistryWrapper } from './contract_wrappers/token_registry_wrapper';
-import { TokenTransferProxyWrapper } from './contract_wrappers/token_transfer_proxy_wrapper';
-import { TokenWrapper } from './contract_wrappers/token_wrapper';
-import { OrderStateWatcher } from './order_watcher/order_state_watcher';
-import { zeroExConfigSchema } from './schemas/zero_ex_config_schema';
-import {
-    ECSignature,
-    Order,
-    SignedOrder,
-    TransactionReceiptWithDecodedLogs,
-    Web3Provider,
-    ZeroExConfig,
-    ZeroExError,
-} from './types';
-import { AbiDecoder } from './utils/abi_decoder';
-import { assert } from './utils/assert';
-import { constants } from './utils/constants';
-import { decorators } from './utils/decorators';
-import { signatureUtils } from './utils/signature_utils';
-import { utils } from './utils/utils';
-
-/**
- * The ZeroEx class is the single entry-point into the 0x.js library. It contains all of the library's functionality
- * and all calls to the library should be made through a ZeroEx instance.
- */
-export class ZeroEx {
-    /**
-     * When creating an order without a specified taker or feeRecipient you must supply the Solidity
-     * address null type (as opposed to Javascripts `null`, `undefined` or empty string). We expose
-     * this constant for your convenience.
-     */
-    public static NULL_ADDRESS = constants.NULL_ADDRESS;
-
-    /**
-     * An instance of the ExchangeWrapper class containing methods for interacting with the 0x Exchange smart contract.
-     */
-    public exchange: ExchangeWrapper;
-    /**
-     * An instance of the TokenRegistryWrapper class containing methods for interacting with the 0x
-     * TokenRegistry smart contract.
-     */
-    public tokenRegistry: TokenRegistryWrapper;
-    /**
-     * An instance of the TokenWrapper class containing methods for interacting with any ERC20 token smart contract.
-     */
-    public token: TokenWrapper;
-    /**
-     * An instance of the EtherTokenWrapper class containing methods for interacting with the
-     * wrapped ETH ERC20 token smart contract.
-     */
-    public etherToken: EtherTokenWrapper;
-    /**
-     * An instance of the TokenTransferProxyWrapper class containing methods for interacting with the
-     * tokenTransferProxy smart contract.
-     */
-    public proxy: TokenTransferProxyWrapper;
-    /**
-     * 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.
-     * @param   data          The hex encoded data signed by the supplied signature.
-     * @param   signature     An object containing the elliptic curve signature parameters.
-     * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
-     * @return  Whether the signature is valid for the supplied signerAddress and data.
-     */
-    public static isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
-        assert.isHexString('data', data);
-        assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
-        assert.isETHAddressHex('signerAddress', signerAddress);
-
-        const isValidSignature = signatureUtils.isValidSignature(data, signature, signerAddress);
-        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
-     * and will not collide with other outstanding orders that are identical in all other parameters.
-     * @return  A pseudo-random 256-bit number that can be used as a salt.
-     */
-    public static generatePseudoRandomSalt(): BigNumber {
-        // BigNumber.random returns a pseudo-random number between 0 & 1 with a passed in number of decimal places.
-        // Source: https://mikemcl.github.io/bignumber.js/#random
-        const randomNumber = BigNumber.random(constants.MAX_DIGITS_IN_UNSIGNED_256_INT);
-        const factor = new BigNumber(10).pow(constants.MAX_DIGITS_IN_UNSIGNED_256_INT - 1);
-        const salt = randomNumber.times(factor).round();
-        return salt;
-    }
-    /**
-     * Checks if the supplied hex encoded order hash is valid.
-     * Note: Valid means it has the expected format, not that an order with the orderHash exists.
-     * Use this method when processing orderHashes submitted as user input.
-     * @param   orderHash    Hex encoded orderHash.
-     * @return  Whether the supplied orderHash has the expected format.
-     */
-    public static isValidOrderHash(orderHash: string): boolean {
-        // Since this method can be called to check if any arbitrary string conforms to an orderHash's
-        // format, we only assert that we were indeed passed a string.
-        assert.isString('orderHash', orderHash);
-        const schemaValidator = new SchemaValidator();
-        const isValidOrderHash = schemaValidator.validate(orderHash, schemas.orderHashSchema).valid;
-        return isValidOrderHash;
-    }
-    /**
-     * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
-     * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
-     * to 1 unit.
-     * @param   amount      The amount in baseUnits that you would like converted to units.
-     * @param   decimals    The number of decimal places the unit amount has.
-     * @return  The amount in units.
-     */
-    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;
-    }
-    /**
-     * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
-     * is the amount expressed in the smallest denomination.
-     * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
-     * @param   amount      The amount of units that you would like converted to baseUnits.
-     * @param   decimals    The number of decimal places the unit amount has.
-     * @return  The amount in baseUnits.
-     */
-    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`);
-        }
-        return baseUnitAmount;
-    }
-    /**
-     * Computes the orderHash for a supplied order.
-     * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
-     * @return  The resulting orderHash from hashing the supplied order.
-     */
-    @decorators.syncZeroExErrorHandler
-    public static getOrderHashHex(order: Order | SignedOrder): string {
-        assert.doesConformToSchema('order', order, schemas.orderSchema);
-        const orderHashHex = utils.getOrderHashHex(order);
-        return orderHashHex;
-    }
-    /**
-     * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
-     * @param   provider    The Web3.js 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) {
-        assert.isWeb3Provider('provider', provider);
-        assert.doesConformToSchema('config', config, zeroExConfigSchema);
-        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);
-        this.proxy = new TokenTransferProxyWrapper(
-            this._web3Wrapper,
-            config.networkId,
-            config.tokenTransferProxyContractAddress,
-        );
-        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.proxy);
-        this.exchange = new ExchangeWrapper(
-            this._web3Wrapper,
-            config.networkId,
-            this._abiDecoder,
-            this.token,
-            config.exchangeContractAddress,
-        );
-        this.tokenRegistry = new TokenRegistryWrapper(
-            this._web3Wrapper,
-            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,
-        );
-    }
-    /**
-     * Sets a new web3 provider for 0x.js. Updating the provider will stop all
-     * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
-     * @param   provider    The Web3Provider you would like the 0x.js library to use from now on.
-     * @param   networkId   The id of the network your provider is connected to
-     */
-    public setProvider(provider: Web3Provider, networkId: number): void {
-        this._web3Wrapper.setProvider(provider);
-        (this.exchange as any)._invalidateContractInstances();
-        (this.exchange as any)._setNetworkId(networkId);
-        (this.tokenRegistry as any)._invalidateContractInstance();
-        (this.tokenRegistry as any)._setNetworkId(networkId);
-        (this.token as any)._invalidateContractInstances();
-        (this.token as any)._setNetworkId(networkId);
-        (this.proxy as any)._invalidateContractInstance();
-        (this.proxy as any)._setNetworkId(networkId);
-        (this.etherToken as any)._invalidateContractInstance();
-        (this.etherToken as any)._setNetworkId(networkId);
-    }
-    /**
-     * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
-     * @return  An array of available user Ethereum addresses.
-     */
-    public async getAvailableAddressesAsync(): Promise<string[]> {
-        const availableAddresses = await this._web3Wrapper.getAvailableAddressesAsync();
-        return availableAddresses;
-    }
-    /**
-     * Signs an orderHash and returns it's elliptic curve signature.
-     * 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.
-     * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
-     */
-    public async signOrderHashAsync(orderHash: string, signerAddress: string): Promise<ECSignature> {
-        assert.isHexString('orderHash', orderHash);
-        await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
-
-        let msgHashHex;
-        const nodeVersion = await this._web3Wrapper.getNodeVersionAsync();
-        const isParityNode = utils.isParityNode(nodeVersion);
-        const isTestRpc = utils.isTestRpc(nodeVersion);
-        if (isParityNode || isTestRpc) {
-            // Parity and TestRpc nodes add the personalMessage prefix itself
-            msgHashHex = orderHash;
-        } else {
-            const orderHashBuff = ethUtil.toBuffer(orderHash);
-            const msgHashBuff = ethUtil.hashPersonalMessage(orderHashBuff);
-            msgHashHex = ethUtil.bufferToHex(msgHashBuff);
-        }
-
-        const signature = await this._web3Wrapper.signTransactionAsync(signerAddress, msgHashHex);
-
-        // HACK: There is no consensus on whether the signatureHex string should be formatted as
-        // v + r + s OR r + s + v, and different clients (even different versions of the same client)
-        // return the signature params in different orders. In order to support all client implementations,
-        // we parse the signature in both ways, and evaluate if either one is a valid signature.
-        const validVParamValues = [27, 28];
-        const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
-        if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, signerAddress);
-            if (isValidVRSSignature) {
-                return ecSignatureVRS;
-            }
-        }
-
-        const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
-        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, signerAddress);
-            if (isValidRSVSignature) {
-                return ecSignatureRSV;
-            }
-        }
-
-        throw new Error(ZeroExError.InvalidSignature);
-    }
-    /**
-     * Waits for a transaction to be mined and returns the transaction receipt.
-     * @param   txHash            Transaction hash
-     * @param   pollingIntervalMs How often (in ms) should we check if the transaction is mined.
-     * @param   timeoutMs         How long (in ms) to poll for transaction mined until aborting.
-     * @return  Transaction receipt with decoded log args.
-     */
-    public async awaitTransactionMinedAsync(
-        txHash: string,
-        pollingIntervalMs = 1000,
-        timeoutMs?: number,
-    ): Promise<TransactionReceiptWithDecodedLogs> {
-        let timeoutExceeded = false;
-        if (timeoutMs) {
-            setTimeout(() => (timeoutExceeded = true), timeoutMs);
-        }
-
-        const txReceiptPromise = new Promise(
-            (resolve: (receipt: TransactionReceiptWithDecodedLogs) => void, reject) => {
-                const intervalId = intervalUtils.setAsyncExcludingInterval(async () => {
-                    if (timeoutExceeded) {
-                        intervalUtils.clearAsyncExcludingInterval(intervalId);
-                        return reject(ZeroExError.TransactionMiningTimeout);
-                    }
-
-                    const transactionReceipt = await this._web3Wrapper.getTransactionReceiptAsync(txHash);
-                    if (!_.isNull(transactionReceipt)) {
-                        intervalUtils.clearAsyncExcludingInterval(intervalId);
-                        const logsWithDecodedArgs = _.map(
-                            transactionReceipt.logs,
-                            this._abiDecoder.tryToDecodeLogOrNoop.bind(this._abiDecoder),
-                        );
-                        const transactionReceiptWithDecodedLogArgs: TransactionReceiptWithDecodedLogs = {
-                            ...transactionReceipt,
-                            logs: logsWithDecodedArgs,
-                        };
-                        resolve(transactionReceiptWithDecodedLogArgs);
-                    }
-                }, pollingIntervalMs);
-            },
-        );
-
-        return txReceiptPromise;
-    }
-    /*
-     * HACK: `TokenWrapper` needs a token transfer proxy address. `TokenTransferProxy` address is fetched from
-     * an `ExchangeWrapper`. `ExchangeWrapper` needs `TokenWrapper` to validate orders, creating a dependency cycle.
-     * In order to break this - we create this function here and pass it as a parameter to the `TokenWrapper`
-     * and `ProxyWrapper`.
-     */
-    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
-        const tokenTransferProxyAddress = await (this.exchange as any)._getTokenTransferProxyAddressAsync();
-        return tokenTransferProxyAddress;
-    }
-}

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

@@ -1,18 +0,0 @@
-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 { Artifact } from './types';
-
-export const artifacts = {
-    ZRXArtifact: (ZRXArtifact as any) as Artifact,
-    DummyTokenArtifact: (DummyTokenArtifact as any) as Artifact,
-    TokenArtifact: (TokenArtifact as any) as Artifact,
-    ExchangeArtifact: (ExchangeArtifact as any) as Artifact,
-    EtherTokenArtifact: (EtherTokenArtifact as any) as Artifact,
-    TokenRegistryArtifact: (TokenRegistryArtifact as any) as Artifact,
-    TokenTransferProxyArtifact: (TokenTransferProxyArtifact as any) as Artifact,
-};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,909 +0,0 @@
-import { schemas } from '@0xproject/json-schemas';
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as _ from 'lodash';
-import * as Web3 from 'web3';
-
-import { artifacts } from '../artifacts';
-import {
-    BlockParamLiteral,
-    BlockRange,
-    DecodedLogArgs,
-    ECSignature,
-    EventCallback,
-    ExchangeContractErrCodes,
-    ExchangeContractErrs,
-    ExchangeContractEventArgs,
-    ExchangeEvents,
-    IndexedFilterValues,
-    LogErrorContractEventArgs,
-    LogWithDecodedArgs,
-    MethodOpts,
-    Order,
-    OrderAddresses,
-    OrderCancellationRequest,
-    OrderFillRequest,
-    OrderTransactionOpts,
-    OrderValues,
-    SignedOrder,
-    ValidateOrderFillableOpts,
-} from '../types';
-import { AbiDecoder } from '../utils/abi_decoder';
-import { assert } from '../utils/assert';
-import { decorators } from '../utils/decorators';
-import { ExchangeTransferSimulator } from '../utils/exchange_transfer_simulator';
-import { OrderValidationUtils } from '../utils/order_validation_utils';
-import { utils } from '../utils/utils';
-
-import { ContractWrapper } from './contract_wrapper';
-import { ExchangeContract } from './generated/exchange';
-import { TokenWrapper } from './token_wrapper';
-
-const SHOULD_VALIDATE_BY_DEFAULT = true;
-
-interface ExchangeContractErrCodesToMsgs {
-    [exchangeContractErrCodes: number]: string;
-}
-
-/**
- * This class includes all the functionality related to calling methods and subscribing to
- * events of the 0x Exchange smart contract.
- */
-export class ExchangeWrapper extends ContractWrapper {
-    private _exchangeContractIfExists?: ExchangeContract;
-    private _orderValidationUtils: OrderValidationUtils;
-    private _tokenWrapper: TokenWrapper;
-    private _exchangeContractErrCodesToMsg: ExchangeContractErrCodesToMsgs = {
-        [ExchangeContractErrCodes.ERROR_FILL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
-        [ExchangeContractErrCodes.ERROR_CANCEL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
-        [ExchangeContractErrCodes.ERROR_FILL_NO_VALUE]: ExchangeContractErrs.OrderRemainingFillAmountZero,
-        [ExchangeContractErrCodes.ERROR_CANCEL_NO_VALUE]: ExchangeContractErrs.OrderRemainingFillAmountZero,
-        [ExchangeContractErrCodes.ERROR_FILL_TRUNCATION]: ExchangeContractErrs.OrderFillRoundingError,
-        [ExchangeContractErrCodes.ERROR_FILL_BALANCE_ALLOWANCE]: ExchangeContractErrs.FillBalanceAllowanceError,
-    };
-    private _contractAddressIfExists?: string;
-    private _zrxContractAddressIfExists?: string;
-    private static _getOrderAddressesAndValues(order: Order): [OrderAddresses, OrderValues] {
-        const orderAddresses: OrderAddresses = [
-            order.maker,
-            order.taker,
-            order.makerTokenAddress,
-            order.takerTokenAddress,
-            order.feeRecipient,
-        ];
-        const orderValues: OrderValues = [
-            order.makerTokenAmount,
-            order.takerTokenAmount,
-            order.makerFee,
-            order.takerFee,
-            order.expirationUnixTimestampSec,
-            order.salt,
-        ];
-        return [orderAddresses, orderValues];
-    }
-    constructor(
-        web3Wrapper: Web3Wrapper,
-        networkId: number,
-        abiDecoder: AbiDecoder,
-        tokenWrapper: TokenWrapper,
-        contractAddressIfExists?: string,
-    ) {
-        super(web3Wrapper, networkId, abiDecoder);
-        this._tokenWrapper = tokenWrapper;
-        this._orderValidationUtils = new OrderValidationUtils(this);
-        this._contractAddressIfExists = contractAddressIfExists;
-    }
-    /**
-     * Returns the unavailable takerAmount of an order. Unavailable amount is defined as the total
-     * amount that has been filled or cancelled. The remaining takerAmount can be calculated by
-     * subtracting the unavailable amount from the total order takerAmount.
-     * @param   orderHash               The hex encoded orderHash for which you would like to retrieve the
-     *                                  unavailable takerAmount.
-     * @param   methodOpts              Optional arguments this method accepts.
-     * @return  The amount of the order (in taker tokens) that has either been filled or cancelled.
-     */
-    public async getUnavailableTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
-        assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
-
-        const exchangeContract = await this._getExchangeContractAsync();
-        const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let unavailableTakerTokenAmount = await exchangeContract.getUnavailableTakerTokenAmount.callAsync(
-            orderHash,
-            defaultBlock,
-        );
-        // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
-        unavailableTakerTokenAmount = new BigNumber(unavailableTakerTokenAmount);
-        return unavailableTakerTokenAmount;
-    }
-    /**
-     * Retrieve the takerAmount of an order that has already been filled.
-     * @param   orderHash    The hex encoded orderHash for which you would like to retrieve the filled takerAmount.
-     * @param   methodOpts   Optional arguments this method accepts.
-     * @return  The amount of the order (in taker tokens) that has already been filled.
-     */
-    public async getFilledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
-        assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
-
-        const exchangeContract = await this._getExchangeContractAsync();
-        const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, defaultBlock);
-        // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
-        fillAmountInBaseUnits = new BigNumber(fillAmountInBaseUnits);
-        return fillAmountInBaseUnits;
-    }
-    /**
-     * Retrieve the takerAmount of an order that has been cancelled.
-     * @param   orderHash    The hex encoded orderHash for which you would like to retrieve the
-     *                       cancelled takerAmount.
-     * @param   methodOpts   Optional arguments this method accepts.
-     * @return  The amount of the order (in taker tokens) that has been cancelled.
-     */
-    public async getCancelledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
-        assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
-
-        const exchangeContract = await this._getExchangeContractAsync();
-        const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
-        let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, defaultBlock);
-        // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
-        cancelledAmountInBaseUnits = new BigNumber(cancelledAmountInBaseUnits);
-        return cancelledAmountInBaseUnits;
-    }
-    /**
-     * Fills a signed order with an amount denominated in baseUnits of the taker token.
-     * Since the order in which transactions are included in the next block is indeterminate, race-conditions
-     * could arise where a users balance or allowance changes before the fillOrder executes. Because of this,
-     * we allow you to specify `shouldThrowOnInsufficientBalanceOrAllowance`.
-     * If false, the smart contract will not throw if the parties
-     * do not have sufficient balances/allowances, preserving gas costs. Setting it to true forgoes this check
-     * and causes the smart contract to throw (using all the gas supplied) instead.
-     * @param   signedOrder                                 An object that conforms to the SignedOrder interface.
-     * @param   fillTakerTokenAmount                        The amount of the order (in taker tokens baseUnits) that
-     *                                                      you wish to fill.
-     * @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
-     *                                                      passed to 0x.js.
-     * @param   orderTransactionOpts                        Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrderAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-            await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                exchangeTradeEmulator,
-                signedOrder,
-                fillTakerTokenAmount,
-                takerAddress,
-                zrxTokenAddress,
-            );
-        }
-
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
-
-        const txHash: string = await exchangeInstance.fillOrder.sendTransactionAsync(
-            orderAddresses,
-            orderValues,
-            fillTakerTokenAmount,
-            shouldThrowOnInsufficientBalanceOrAllowance,
-            signedOrder.ecSignature.v,
-            signedOrder.ecSignature.r,
-            signedOrder.ecSignature.s,
-            {
-                from: takerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Sequentially and atomically fills signedOrders up to the specified takerTokenFillAmount.
-     * If the fill amount is reached - it succeeds and does not fill the rest of the orders.
-     * If fill amount is not reached - it fills as much of the fill amount as possible and succeeds.
-     * @param   signedOrders                                The array of signedOrders that you would like to fill until
-     *                                                      takerTokenFillAmount is reached.
-     * @param   fillTakerTokenAmount                        The total amount of the takerTokens you would like to fill.
-     * @param   shouldThrowOnInsufficientBalanceOrAllowance Whether or not you wish for the contract call to throw if
-     *                                                      upon execution any of the tokens cannot be transferred.
-     *                                                      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
-     *                                                      passed to 0x.js.
-     * @param   orderTransactionOpts                        Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrdersUpToAsync(
-        signedOrders: SignedOrder[],
-        fillTakerTokenAmount: BigNumber,
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('signedOrders', signedOrders, schemas.signedOrdersSchema);
-        const takerTokenAddresses = _.map(signedOrders, signedOrder => signedOrder.takerTokenAddress);
-        assert.hasAtMostOneUniqueValue(
-            takerTokenAddresses,
-            ExchangeContractErrs.MultipleTakerTokensInFillUpToDisallowed,
-        );
-        const exchangeContractAddresses = _.map(signedOrders, signedOrder => signedOrder.exchangeContractAddress);
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-            for (const signedOrder of signedOrders) {
-                await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    signedOrder,
-                    fillTakerTokenAmount,
-                    takerAddress,
-                    zrxTokenAddress,
-                );
-            }
-        }
-
-        if (_.isEmpty(signedOrders)) {
-            throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-        }
-
-        const orderAddressesValuesAndSignatureArray = _.map(signedOrders, signedOrder => {
-            return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(signedOrder),
-                signedOrder.ecSignature.v,
-                signedOrder.ecSignature.r,
-                signedOrder.ecSignature.s,
-            ];
-        });
-        // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddressesArray, orderValuesArray, vArray, rArray, sArray] = _.unzip<any>(
-            orderAddressesValuesAndSignatureArray,
-        );
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const txHash = await exchangeInstance.fillOrdersUpTo.sendTransactionAsync(
-            orderAddressesArray,
-            orderValuesArray,
-            fillTakerTokenAmount,
-            shouldThrowOnInsufficientBalanceOrAllowance,
-            vArray,
-            rArray,
-            sArray,
-            {
-                from: takerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Batch version of fillOrderAsync.
-     * Executes multiple fills atomically in a single transaction.
-     * If shouldThrowOnInsufficientBalanceOrAllowance is set to false, it will continue filling subsequent orders even
-     * when earlier ones fail.
-     * When shouldThrowOnInsufficientBalanceOrAllowance is set to true, if any fill fails, the entire batch fails.
-     * @param   orderFillRequests                               An array of objects that conform to the
-     *                                                          OrderFillRequest interface.
-     * @param   shouldThrowOnInsufficientBalanceOrAllowance     Whether or not you wish for the contract call to throw
-     *                                                          if upon execution any of the tokens cannot be
-     *                                                          transferred. 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 passed to 0x.js.
-     * @param   orderTransactionOpts                            Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async batchFillOrdersAsync(
-        orderFillRequests: OrderFillRequest[],
-        shouldThrowOnInsufficientBalanceOrAllowance: boolean,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
-        const exchangeContractAddresses = _.map(
-            orderFillRequests,
-            orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
-        );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
-        assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-            for (const orderFillRequest of orderFillRequests) {
-                await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    orderFillRequest.signedOrder,
-                    orderFillRequest.takerTokenFillAmount,
-                    takerAddress,
-                    zrxTokenAddress,
-                );
-            }
-        }
-        if (_.isEmpty(orderFillRequests)) {
-            throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-        }
-
-        const orderAddressesValuesAmountsAndSignatureArray = _.map(orderFillRequests, orderFillRequest => {
-            return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(orderFillRequest.signedOrder),
-                orderFillRequest.takerTokenFillAmount,
-                orderFillRequest.signedOrder.ecSignature.v,
-                orderFillRequest.signedOrder.ecSignature.r,
-                orderFillRequest.signedOrder.ecSignature.s,
-            ];
-        });
-        // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddressesArray, orderValuesArray, fillTakerTokenAmounts, vArray, rArray, sArray] = _.unzip<any>(
-            orderAddressesValuesAmountsAndSignatureArray,
-        );
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const txHash = await exchangeInstance.batchFillOrders.sendTransactionAsync(
-            orderAddressesArray,
-            orderValuesArray,
-            fillTakerTokenAmounts,
-            shouldThrowOnInsufficientBalanceOrAllowance,
-            vArray,
-            rArray,
-            sArray,
-            {
-                from: takerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Attempts to fill a specific amount of an order. If the entire amount specified cannot be filled,
-     * the fill order is abandoned.
-     * @param   signedOrder             An object that conforms to the SignedOrder interface. The
-     *                                  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.
-     * @param   orderTransactionOpts    Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async fillOrKillOrderAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-            await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-                exchangeTradeEmulator,
-                signedOrder,
-                fillTakerTokenAmount,
-                takerAddress,
-                zrxTokenAddress,
-            );
-        }
-
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(signedOrder);
-        const txHash = await exchangeInstance.fillOrKillOrder.sendTransactionAsync(
-            orderAddresses,
-            orderValues,
-            fillTakerTokenAmount,
-            signedOrder.ecSignature.v,
-            signedOrder.ecSignature.r,
-            signedOrder.ecSignature.s,
-            {
-                from: takerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Batch version of fillOrKill. Allows a taker to specify a batch of orders that will either be atomically
-     * 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.
-     * @param   orderTransactionOpts        Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async batchFillOrKillAsync(
-        orderFillRequests: OrderFillRequest[],
-        takerAddress: string,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
-        const exchangeContractAddresses = _.map(
-            orderFillRequests,
-            orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
-        );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        if (_.isEmpty(orderFillRequests)) {
-            throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-        }
-        const exchangeInstance = await this._getExchangeContractAsync();
-
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const zrxTokenAddress = this.getZRXTokenAddress();
-            const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-            for (const orderFillRequest of orderFillRequests) {
-                await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-                    exchangeTradeEmulator,
-                    orderFillRequest.signedOrder,
-                    orderFillRequest.takerTokenFillAmount,
-                    takerAddress,
-                    zrxTokenAddress,
-                );
-            }
-        }
-
-        const orderAddressesValuesAndTakerTokenFillAmounts = _.map(orderFillRequests, request => {
-            return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(request.signedOrder),
-                request.takerTokenFillAmount,
-                request.signedOrder.ecSignature.v,
-                request.signedOrder.ecSignature.r,
-                request.signedOrder.ecSignature.s,
-            ];
-        });
-
-        // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddresses, orderValues, fillTakerTokenAmounts, vParams, rParams, sParams] = _.unzip<any>(
-            orderAddressesValuesAndTakerTokenFillAmounts,
-        );
-        const txHash = await exchangeInstance.batchFillOrKillOrders.sendTransactionAsync(
-            orderAddresses,
-            orderValues,
-            fillTakerTokenAmounts,
-            vParams,
-            rParams,
-            sParams,
-            {
-                from: takerAddress,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Cancel a given fill amount of an order. Cancellations are cumulative.
-     * @param   order                   An object that conforms to the Order or SignedOrder interface.
-     *                                  The order you would like to cancel.
-     * @param   cancelTakerTokenAmount  The amount (specified in taker tokens) that you would like to cancel.
-     * @param   transactionOpts         Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async cancelOrderAsync(
-        order: Order | SignedOrder,
-        cancelTakerTokenAmount: BigNumber,
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema('order', order, schemas.orderSchema);
-        assert.isValidBaseUnitAmount('takerTokenCancelAmount', cancelTakerTokenAmount);
-        await assert.isSenderAddressAsync('order.maker', order.maker, this._web3Wrapper);
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            const orderHash = utils.getOrderHashHex(order);
-            const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-            OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-                order,
-                cancelTakerTokenAmount,
-                unavailableTakerTokenAmount,
-            );
-        }
-
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
-        const txHash = await exchangeInstance.cancelOrder.sendTransactionAsync(
-            orderAddresses,
-            orderValues,
-            cancelTakerTokenAmount,
-            {
-                from: order.maker,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Batch version of cancelOrderAsync. Atomically cancels multiple orders in a single transaction.
-     * All orders must be from the same maker.
-     * @param   orderCancellationRequests   An array of objects that conform to the OrderCancellationRequest
-     *                                      interface.
-     * @param   transactionOpts             Optional arguments this method accepts.
-     * @return  Transaction hash.
-     */
-    @decorators.asyncZeroExErrorHandler
-    public async batchCancelOrdersAsync(
-        orderCancellationRequests: OrderCancellationRequest[],
-        orderTransactionOpts: OrderTransactionOpts = {},
-    ): Promise<string> {
-        assert.doesConformToSchema(
-            'orderCancellationRequests',
-            orderCancellationRequests,
-            schemas.orderCancellationRequestsSchema,
-        );
-        const exchangeContractAddresses = _.map(
-            orderCancellationRequests,
-            orderCancellationRequest => orderCancellationRequest.order.exchangeContractAddress,
-        );
-        assert.hasAtMostOneUniqueValue(
-            exchangeContractAddresses,
-            ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
-        );
-        const makers = _.map(orderCancellationRequests, cancellationRequest => cancellationRequest.order.maker);
-        assert.hasAtMostOneUniqueValue(makers, ExchangeContractErrs.MultipleMakersInSingleCancelBatchDisallowed);
-        const maker = makers[0];
-        await assert.isSenderAddressAsync('maker', maker, this._web3Wrapper);
-        const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
-            ? SHOULD_VALIDATE_BY_DEFAULT
-            : orderTransactionOpts.shouldValidate;
-        if (shouldValidate) {
-            for (const orderCancellationRequest of orderCancellationRequests) {
-                const orderHash = utils.getOrderHashHex(orderCancellationRequest.order);
-                const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-                OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-                    orderCancellationRequest.order,
-                    orderCancellationRequest.takerTokenCancelAmount,
-                    unavailableTakerTokenAmount,
-                );
-            }
-        }
-        if (_.isEmpty(orderCancellationRequests)) {
-            throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-        }
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const orderAddressesValuesAndTakerTokenCancelAmounts = _.map(orderCancellationRequests, cancellationRequest => {
-            return [
-                ...ExchangeWrapper._getOrderAddressesAndValues(cancellationRequest.order),
-                cancellationRequest.takerTokenCancelAmount,
-            ];
-        });
-        // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
-        const [orderAddresses, orderValues, cancelTakerTokenAmounts] = _.unzip<any>(
-            orderAddressesValuesAndTakerTokenCancelAmounts,
-        );
-        const txHash = await exchangeInstance.batchCancelOrders.sendTransactionAsync(
-            orderAddresses,
-            orderValues,
-            cancelTakerTokenAmounts,
-            {
-                from: maker,
-                gas: orderTransactionOpts.gasLimit,
-                gasPrice: orderTransactionOpts.gasPrice,
-            },
-        );
-        return txHash;
-    }
-    /**
-     * Subscribe to an event type emitted by the Exchange contract.
-     * @param   eventName           The exchange contract event you would like to subscribe to.
-     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
-     *                              the value is the value you are interested in. E.g `{maker: aUserAddressHex}`
-     * @param   callback            Callback that gets called when a log is added/removed
-     * @return Subscription token used later to unsubscribe
-     */
-    public subscribe<ArgsType extends ExchangeContractEventArgs>(
-        eventName: ExchangeEvents,
-        indexFilterValues: IndexedFilterValues,
-        callback: EventCallback<ArgsType>,
-    ): string {
-        assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
-        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
-        assert.isFunction('callback', callback);
-        const exchangeContractAddress = this.getContractAddress();
-        const subscriptionToken = this._subscribe<ArgsType>(
-            exchangeContractAddress,
-            eventName,
-            indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
-            callback,
-        );
-        return subscriptionToken;
-    }
-    /**
-     * Cancel a subscription
-     * @param   subscriptionToken Subscription token returned by `subscribe()`
-     */
-    public unsubscribe(subscriptionToken: string): void {
-        this._unsubscribe(subscriptionToken);
-    }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        super.unsubscribeAll();
-    }
-    /**
-     * Gets historical logs without creating a subscription
-     * @param   eventName           The exchange contract event you would like to subscribe to.
-     * @param   blockRange          Block range to get logs from.
-     * @param   indexFilterValues   An object where the keys are indexed args returned by the event and
-     *                              the value is the value you are interested in. E.g `{_from: aUserAddressHex}`
-     * @return  Array of logs that match the parameters
-     */
-    public async getLogsAsync<ArgsType extends ExchangeContractEventArgs>(
-        eventName: ExchangeEvents,
-        blockRange: BlockRange,
-        indexFilterValues: IndexedFilterValues,
-    ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
-        assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
-        assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
-        assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
-        const exchangeContractAddress = this.getContractAddress();
-        const logs = await this._getLogsAsync<ArgsType>(
-            exchangeContractAddress,
-            eventName,
-            blockRange,
-            indexFilterValues,
-            artifacts.ExchangeArtifact.abi,
-        );
-        return logs;
-    }
-    /**
-     * Retrieves the Ethereum address of the Exchange contract deployed on the network
-     * that the user-passed web3 provider is connected to.
-     * @returns The Ethereum address of the Exchange contract being used.
-     */
-    public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ExchangeArtifact, this._contractAddressIfExists);
-        return contractAddress;
-    }
-    /**
-     * Checks if order is still fillable and throws an error otherwise. Useful for orderbook
-     * pruning where you want to remove stale orders without knowing who the taker will be.
-     * @param   signedOrder     An object that conforms to the SignedOrder interface. The
-     *                          signedOrder you wish to validate.
-     * @param   opts            An object that conforms to the ValidateOrderFillableOpts
-     *                          interface. Allows specifying a specific fillTakerTokenAmount
-     *                          to validate for.
-     */
-    public async validateOrderFillableOrThrowAsync(
-        signedOrder: SignedOrder,
-        opts?: ValidateOrderFillableOpts,
-    ): Promise<void> {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        const zrxTokenAddress = this.getZRXTokenAddress();
-        const expectedFillTakerTokenAmount = !_.isUndefined(opts) ? opts.expectedFillTakerTokenAmount : undefined;
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-        await this._orderValidationUtils.validateOrderFillableOrThrowAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            zrxTokenAddress,
-            expectedFillTakerTokenAmount,
-        );
-    }
-    /**
-     * Checks if order fill will succeed and throws an error otherwise.
-     * @param   signedOrder             An object that conforms to the SignedOrder interface. The
-     *                                  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.
-     */
-    public async validateFillOrderThrowIfInvalidAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-    ): Promise<void> {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const zrxTokenAddress = this.getZRXTokenAddress();
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-        await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            fillTakerTokenAmount,
-            takerAddress,
-            zrxTokenAddress,
-        );
-    }
-    /**
-     * Checks if cancelling a given order will succeed and throws an informative error if it won't.
-     * @param   order                   An object that conforms to the Order or SignedOrder interface.
-     *                                  The order you would like to cancel.
-     * @param   cancelTakerTokenAmount  The amount (specified in taker tokens) that you would like to cancel.
-     */
-    public async validateCancelOrderThrowIfInvalidAsync(
-        order: Order,
-        cancelTakerTokenAmount: BigNumber,
-    ): Promise<void> {
-        assert.doesConformToSchema('order', order, schemas.orderSchema);
-        assert.isValidBaseUnitAmount('cancelTakerTokenAmount', cancelTakerTokenAmount);
-        const orderHash = utils.getOrderHashHex(order);
-        const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils.validateCancelOrderThrowIfInvalid(
-            order,
-            cancelTakerTokenAmount,
-            unavailableTakerTokenAmount,
-        );
-    }
-    /**
-     * Checks if calling fillOrKill on a given order will succeed and throws an informative error if it won't.
-     * @param   signedOrder             An object that conforms to the SignedOrder interface. The
-     *                                  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.
-     */
-    public async validateFillOrKillOrderThrowIfInvalidAsync(
-        signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber,
-        takerAddress: string,
-    ): Promise<void> {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
-        const zrxTokenAddress = this.getZRXTokenAddress();
-        const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
-        await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
-            exchangeTradeEmulator,
-            signedOrder,
-            fillTakerTokenAmount,
-            takerAddress,
-            zrxTokenAddress,
-        );
-    }
-    /**
-     * Checks if rounding error will be > 0.1% when computing makerTokenAmount by doing:
-     * `(fillTakerTokenAmount * makerTokenAmount) / takerTokenAmount`.
-     * 0x Protocol does not accept any trades that result in large rounding errors. This means that tokens with few or
-     * no decimals can only be filled in quantities and ratios that avoid large rounding errors.
-     * @param   fillTakerTokenAmount   The amount of the order (in taker tokens baseUnits) that you wish to fill.
-     * @param   takerTokenAmount       The order size on the taker side
-     * @param   makerTokenAmount       The order size on the maker side
-     */
-    public async isRoundingErrorAsync(
-        fillTakerTokenAmount: BigNumber,
-        takerTokenAmount: BigNumber,
-        makerTokenAmount: BigNumber,
-    ): Promise<boolean> {
-        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
-        assert.isValidBaseUnitAmount('takerTokenAmount', takerTokenAmount);
-        assert.isValidBaseUnitAmount('makerTokenAmount', makerTokenAmount);
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const isRoundingError = await exchangeInstance.isRoundingError.callAsync(
-            fillTakerTokenAmount,
-            takerTokenAmount,
-            makerTokenAmount,
-        );
-        return isRoundingError;
-    }
-    /**
-     * Checks if logs contain LogError, which is emmited by Exchange contract on transaction failure.
-     * @param   logs   Transaction logs as returned by `zeroEx.awaitTransactionMinedAsync`
-     */
-    public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs> | Web3.LogEntry>): void {
-        const errLog = _.find(logs, {
-            event: ExchangeEvents.LogError,
-        }) as LogWithDecodedArgs<LogErrorContractEventArgs> | undefined;
-        if (!_.isUndefined(errLog)) {
-            const logArgs = errLog.args;
-            const errCode = logArgs.errorId.toNumber();
-            const errMessage = this._exchangeContractErrCodesToMsg[errCode];
-            throw new Error(errMessage);
-        }
-    }
-    /**
-     * Returns the ZRX token address used by the exchange contract.
-     * @return Address of ZRX token
-     */
-    public getZRXTokenAddress(): string {
-        const contractAddress = this._getContractAddress(artifacts.ZRXArtifact, this._zrxContractAddressIfExists);
-        return contractAddress;
-    }
-    private _invalidateContractInstances(): void {
-        this.unsubscribeAll();
-        delete this._exchangeContractIfExists;
-    }
-    private async _isValidSignatureUsingContractCallAsync(
-        dataHex: string,
-        ecSignature: ECSignature,
-        signerAddressHex: string,
-    ): Promise<boolean> {
-        assert.isHexString('dataHex', dataHex);
-        assert.doesConformToSchema('ecSignature', ecSignature, schemas.ecSignatureSchema);
-        assert.isETHAddressHex('signerAddressHex', signerAddressHex);
-
-        const exchangeInstance = await this._getExchangeContractAsync();
-
-        const isValidSignature = await exchangeInstance.isValidSignature.callAsync(
-            signerAddressHex,
-            dataHex,
-            ecSignature.v,
-            ecSignature.r,
-            ecSignature.s,
-        );
-        return isValidSignature;
-    }
-    private async _getOrderHashHexUsingContractCallAsync(order: Order | SignedOrder): Promise<string> {
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const [orderAddresses, orderValues] = ExchangeWrapper._getOrderAddressesAndValues(order);
-        const orderHashHex = await exchangeInstance.getOrderHash.callAsync(orderAddresses, orderValues);
-        return orderHashHex;
-    }
-    private async _getExchangeContractAsync(): Promise<ExchangeContract> {
-        if (!_.isUndefined(this._exchangeContractIfExists)) {
-            return this._exchangeContractIfExists;
-        }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
-            artifacts.ExchangeArtifact,
-            this._contractAddressIfExists,
-        );
-        const contractInstance = new ExchangeContract(web3ContractInstance, this._web3Wrapper.getContractDefaults());
-        this._exchangeContractIfExists = contractInstance;
-        return this._exchangeContractIfExists;
-    }
-    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
-        const exchangeInstance = await this._getExchangeContractAsync();
-        const tokenTransferProxyAddress = await exchangeInstance.TOKEN_TRANSFER_PROXY_CONTRACT.callAsync();
-        const tokenTransferProxyAddressLowerCase = tokenTransferProxyAddress.toLowerCase();
-        return tokenTransferProxyAddressLowerCase;
-    }
-} // tslint:disable:max-file-line-count

packages/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

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

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

@@ -1,68 +0,0 @@
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as _ from 'lodash';
-
-import { artifacts } from '../artifacts';
-
-import { ContractWrapper } from './contract_wrapper';
-import { TokenTransferProxyContract } from './generated/token_transfer_proxy';
-
-/**
- * This class includes the functionality related to interacting with the TokenTransferProxy contract.
- */
-export class TokenTransferProxyWrapper extends ContractWrapper {
-    private _tokenTransferProxyContractIfExists?: TokenTransferProxyContract;
-    private _contractAddressIfExists?: string;
-    constructor(web3Wrapper: Web3Wrapper, networkId: number, contractAddressIfExists?: string) {
-        super(web3Wrapper, networkId);
-        this._contractAddressIfExists = contractAddressIfExists;
-    }
-    /**
-     * Check if the Exchange contract address is authorized by the TokenTransferProxy contract.
-     * @param   exchangeContractAddress     The hex encoded address of the Exchange contract to call.
-     * @return  Whether the exchangeContractAddress is authorized.
-     */
-    public async isAuthorizedAsync(exchangeContractAddress: string): Promise<boolean> {
-        const tokenTransferProxyContractInstance = await this._getTokenTransferProxyContractAsync();
-        const isAuthorized = await tokenTransferProxyContractInstance.authorized.callAsync(exchangeContractAddress);
-        return isAuthorized;
-    }
-    /**
-     * Get the list of all Exchange contract addresses authorized by the TokenTransferProxy contract.
-     * @return  The list of authorized addresses.
-     */
-    public async getAuthorizedAddressesAsync(): Promise<string[]> {
-        const tokenTransferProxyContractInstance = await this._getTokenTransferProxyContractAsync();
-        const authorizedAddresses = await tokenTransferProxyContractInstance.getAuthorizedAddresses.callAsync();
-        return authorizedAddresses;
-    }
-    /**
-     * Retrieves the Ethereum address of the TokenTransferProxy contract deployed on the network
-     * that the user-passed web3 provider is connected to.
-     * @returns The Ethereum address of the TokenTransferProxy contract being used.
-     */
-    public getContractAddress(): string {
-        const contractAddress = this._getContractAddress(
-            artifacts.TokenTransferProxyArtifact,
-            this._contractAddressIfExists,
-        );
-        return contractAddress;
-    }
-    private _invalidateContractInstance(): void {
-        delete this._tokenTransferProxyContractIfExists;
-    }
-    private async _getTokenTransferProxyContractAsync(): Promise<TokenTransferProxyContract> {
-        if (!_.isUndefined(this._tokenTransferProxyContractIfExists)) {
-            return this._tokenTransferProxyContractIfExists;
-        }
-        const web3ContractInstance = await this._instantiateContractIfExistsAsync(
-            artifacts.TokenTransferProxyArtifact,
-            this._contractAddressIfExists,
-        );
-        const contractInstance = new TokenTransferProxyContract(
-            web3ContractInstance,
-            this._web3Wrapper.getContractDefaults(),
-        );
-        this._tokenTransferProxyContractIfExists = contractInstance;
-        return this._tokenTransferProxyContractIfExists;
-    }
-}

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

@@ -1,73 +1,6 @@
-/// <reference types='chai-typescript-typings' />
-/// <reference types='chai-as-promised-typescript-typings' />
-declare module 'web3_beta';
-declare module 'chai-bignumber';
-declare module 'dirty-chai';
-declare module 'request-promise-native';
-declare module 'web3-provider-engine';
-declare module 'web3-provider-engine/subproviders/rpc';
-
-// 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 */
 }
-
-// find-version declarations
-declare function findVersions(version: string): string[];
-declare module 'find-versions' {
-    export = findVersions;
-}
-
-// compare-version declarations
-declare function compareVersions(firstVersion: string, secondVersion: string): number;
-declare module 'compare-versions' {
-    export = compareVersions;
-}
-
-declare module 'ethereumjs-abi' {
-    const soliditySHA3: (argTypes: string[], args: any[]) => Buffer;
-}
-
-// truffle-hdwallet-provider declarations
-declare module 'truffle-hdwallet-provider' {
-    import * as Web3 from 'web3';
-    class HDWalletProvider implements Web3.Provider {
-        constructor(mnemonic: string, rpcUrl: string);
-        public sendAsync(
-            payload: Web3.JSONRPCRequestPayload,
-            callback: (err: Error, result: Web3.JSONRPCResponsePayload) => void,
-        ): void;
-    }
-    export = HDWalletProvider;
-}
-
-// abi-decoder declarations
-interface DecodedLogArg {}
-interface DecodedLog {
-    name: string;
-    events: DecodedLogArg[];
-}
-declare module 'abi-decoder' {
-    import * as Web3 from 'web3';
-    const addABI: (abi: Web3.AbiDefinition) => void;
-    const decodeLogs: (logs: Web3.LogEntry[]) => DecodedLog[];
-}
-
-declare module 'web3/lib/solidity/coder' {
-    const decodeParams: (types: string[], data: string) => any[];
-}

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

@@ -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,50 +1,104 @@
-export { ZeroEx } from './0x';
+export { assetDataUtils, signatureUtils, generatePseudoRandomSalt, orderHashUtils } from '@0xproject/order-utils';
 
 export {
-    Order,
-    BlockParamLiteral,
-    SignedOrder,
-    ECSignature,
-    ZeroExError,
-    EventCallback,
-    ExchangeContractErrs,
-    ContractEvent,
-    Token,
-    ExchangeEvents,
-    TokenEvents,
+    ContractWrappers,
+    ERC20TokenWrapper,
+    ERC721TokenWrapper,
+    EtherTokenWrapper,
+    ExchangeWrapper,
+    ERC20ProxyWrapper,
+    ERC721ProxyWrapper,
+    ForwarderWrapper,
+    OrderValidatorWrapper,
     IndexedFilterValues,
     BlockRange,
-    BlockParam,
-    OrderCancellationRequest,
-    OrderFillRequest,
-    LogErrorContractEventArgs,
-    LogCancelContractEventArgs,
-    LogFillContractEventArgs,
-    ExchangeContractEventArgs,
-    TransferContractEventArgs,
-    ApprovalContractEventArgs,
-    TokenContractEventArgs,
-    EtherTokenContractEventArgs,
-    WithdrawalContractEventArgs,
-    DepositContractEventArgs,
-    ContractEventArgs,
-    ContractEventArg,
-    Web3Provider,
-    ZeroExConfig,
-    EtherTokenEvents,
-    TransactionReceiptWithDecodedLogs,
-    LogWithDecodedArgs,
+    ContractWrappersConfig,
     MethodOpts,
     OrderTransactionOpts,
     TransactionOpts,
-    FilterObject,
-    LogEvent,
+    OrderStatus,
+    OrderInfo,
+    WETH9Events,
+    WETH9WithdrawalEventArgs,
+    WETH9ApprovalEventArgs,
+    WETH9EventArgs,
+    WETH9DepositEventArgs,
+    WETH9TransferEventArgs,
+    ERC20TokenTransferEventArgs,
+    ERC20TokenApprovalEventArgs,
+    ERC20TokenEvents,
+    ERC20TokenEventArgs,
+    ERC721TokenApprovalEventArgs,
+    ERC721TokenApprovalForAllEventArgs,
+    ERC721TokenTransferEventArgs,
+    ERC721TokenEvents,
+    ERC721TokenEventArgs,
+    ExchangeCancelUpToEventArgs,
+    ExchangeAssetProxyRegisteredEventArgs,
+    ExchangeSignatureValidatorApprovalEventArgs,
+    ExchangeFillEventArgs,
+    ExchangeCancelEventArgs,
+    ExchangeEvents,
+    EventCallback,
     DecodedLogEvent,
-    EventWatcherCallback,
-    OnOrderStateChangeCallback,
+    ExchangeEventArgs,
+    TransactionEncoder,
+    BalanceAndAllowance,
+    OrderAndTraderInfo,
+    TraderInfo,
+    ValidateOrderFillableOpts,
+} from '@0xproject/contract-wrappers';
+
+export { OrderWatcher, OnOrderStateChangeCallback, OrderWatcherConfig } from '@0xproject/order-watcher';
+
+export import Web3ProviderEngine = require('web3-provider-engine');
+
+export { RPCSubprovider, Callback, JSONRPCRequestPayloadWithMethod, ErrorCallback } from '@0xproject/subproviders';
+
+export { AbiDecoder } from '@0xproject/utils';
+
+export { BigNumber } from '@0xproject/utils';
+
+export {
+    ExchangeContractErrs,
+    Order,
+    SignedOrder,
+    ECSignature,
     OrderStateValid,
     OrderStateInvalid,
     OrderState,
-} from './types';
+    AssetProxyId,
+    SignerType,
+    ERC20AssetData,
+    ERC721AssetData,
+    SignatureType,
+    OrderRelevantState,
+} from '@0xproject/types';
 
-export { TransactionReceipt } from '@0xproject/types';
+export {
+    BlockParamLiteral,
+    ContractAbi,
+    BlockParam,
+    LogWithDecodedArgs,
+    ContractEventArg,
+    Provider,
+    JSONRPCRequestPayload,
+    JSONRPCResponsePayload,
+    JSONRPCErrorCallback,
+    LogEntry,
+    DecodedLogArgs,
+    LogEntryEvent,
+    DecodedLogEntry,
+    DecodedLogEntryEvent,
+    RawLog,
+    AbiDefinition,
+    FunctionAbi,
+    EventAbi,
+    EventParameter,
+    MethodAbi,
+    ConstructorAbi,
+    FallbackAbi,
+    DataItem,
+    ConstructorStateMutability,
+    StateMutability,
+} from 'ethereum-types';

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

@@ -1,85 +0,0 @@
-import { intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as _ from 'lodash';
-import * as Web3 from 'web3';
-
-import { BlockParamLiteral, EventWatcherCallback, ZeroExError } from '../types';
-import { assert } from '../utils/assert';
-
-const DEFAULT_EVENT_POLLING_INTERVAL_MS = 200;
-
-enum LogEventState {
-    Removed,
-    Added,
-}
-
-/*
- * The EventWatcher watches for blockchain events at the specified block confirmation
- * depth.
- */
-export class EventWatcher {
-    private _web3Wrapper: Web3Wrapper;
-    private _pollingIntervalMs: number;
-    private _intervalIdIfExists?: NodeJS.Timer;
-    private _lastEvents: Web3.LogEntry[] = [];
-    constructor(web3Wrapper: Web3Wrapper, pollingIntervalIfExistsMs: undefined | number) {
-        this._web3Wrapper = web3Wrapper;
-        this._pollingIntervalMs = _.isUndefined(pollingIntervalIfExistsMs)
-            ? DEFAULT_EVENT_POLLING_INTERVAL_MS
-            : pollingIntervalIfExistsMs;
-    }
-    public subscribe(callback: EventWatcherCallback): void {
-        assert.isFunction('callback', callback);
-        if (!_.isUndefined(this._intervalIdIfExists)) {
-            throw new Error(ZeroExError.SubscriptionAlreadyPresent);
-        }
-        this._intervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
-            this._pollForBlockchainEventsAsync.bind(this, callback),
-            this._pollingIntervalMs,
-        );
-    }
-    public unsubscribe(): void {
-        this._lastEvents = [];
-        if (!_.isUndefined(this._intervalIdIfExists)) {
-            intervalUtils.clearAsyncExcludingInterval(this._intervalIdIfExists);
-            delete this._intervalIdIfExists;
-        }
-    }
-    private async _pollForBlockchainEventsAsync(callback: EventWatcherCallback): Promise<void> {
-        const pendingEvents = await this._getEventsAsync();
-        if (pendingEvents.length === 0) {
-            // HACK: Sometimes when node rebuilds the pending block we get back the empty result.
-            // We don't want to emit a lot of removal events and bring them back after a couple of miliseconds,
-            // that's why we just ignore those cases.
-            return;
-        }
-        const removedEvents = _.differenceBy(this._lastEvents, pendingEvents, JSON.stringify);
-        const newEvents = _.differenceBy(pendingEvents, this._lastEvents, JSON.stringify);
-        await this._emitDifferencesAsync(removedEvents, LogEventState.Removed, callback);
-        await this._emitDifferencesAsync(newEvents, LogEventState.Added, callback);
-        this._lastEvents = pendingEvents;
-    }
-    private async _getEventsAsync(): Promise<Web3.LogEntry[]> {
-        const eventFilter = {
-            fromBlock: BlockParamLiteral.Pending,
-            toBlock: BlockParamLiteral.Pending,
-        };
-        const events = await this._web3Wrapper.getLogsAsync(eventFilter);
-        return events;
-    }
-    private async _emitDifferencesAsync(
-        logs: Web3.LogEntry[],
-        logEventState: LogEventState,
-        callback: EventWatcherCallback,
-    ): Promise<void> {
-        for (const log of logs) {
-            const logEvent = {
-                removed: logEventState === LogEventState.Removed,
-                ...log,
-            };
-            if (!_.isUndefined(this._intervalIdIfExists)) {
-                callback(logEvent);
-            }
-        }
-    }
-}

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

@@ -1,366 +0,0 @@
-import { schemas } from '@0xproject/json-schemas';
-import { intervalUtils } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import * as _ from 'lodash';
-
-import { ZeroEx } from '../0x';
-import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
-import { TokenWrapper } from '../contract_wrappers/token_wrapper';
-import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
-import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store';
-import {
-    ApprovalContractEventArgs,
-    BlockParamLiteral,
-    ContractEventArgs,
-    DepositContractEventArgs,
-    EtherTokenEvents,
-    ExchangeContractErrs,
-    ExchangeEvents,
-    LogCancelContractEventArgs,
-    LogEvent,
-    LogFillContractEventArgs,
-    LogWithDecodedArgs,
-    OnOrderStateChangeCallback,
-    OrderState,
-    OrderStateWatcherConfig,
-    SignedOrder,
-    TokenEvents,
-    TransferContractEventArgs,
-    WithdrawalContractEventArgs,
-    ZeroExError,
-} from '../types';
-import { AbiDecoder } from '../utils/abi_decoder';
-import { assert } from '../utils/assert';
-import { OrderStateUtils } from '../utils/order_state_utils';
-import { utils } from '../utils/utils';
-
-import { EventWatcher } from './event_watcher';
-import { ExpirationWatcher } from './expiration_watcher';
-
-interface DependentOrderHashes {
-    [makerAddress: string]: {
-        [makerToken: string]: Set<string>;
-    };
-}
-
-interface OrderByOrderHash {
-    [orderHash: string]: SignedOrder;
-}
-
-interface OrderStateByOrderHash {
-    [orderHash: string]: OrderState;
-}
-
-const DEFAULT_CLEANUP_JOB_INTERVAL_MS = 1000 * 60 * 60; // 1h
-
-/**
- * This class includes all the functionality related to watching a set of orders
- * for potential changes in order validity/fillability. The orderWatcher notifies
- * the subscriber of these changes so that a final decison can be made on whether
- * the order should be deemed invalid.
- */
-export class OrderStateWatcher {
-    private _orderStateByOrderHashCache: OrderStateByOrderHash = {};
-    private _orderByOrderHash: OrderByOrderHash = {};
-    private _dependentOrderHashes: DependentOrderHashes = {};
-    private _callbackIfExists?: OnOrderStateChangeCallback;
-    private _eventWatcher: EventWatcher;
-    private _web3Wrapper: Web3Wrapper;
-    private _abiDecoder: AbiDecoder;
-    private _expirationWatcher: ExpirationWatcher;
-    private _orderStateUtils: OrderStateUtils;
-    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
-    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private _cleanupJobInterval: number;
-    private _cleanupJobIntervalIdIfExists?: NodeJS.Timer;
-    constructor(
-        web3Wrapper: Web3Wrapper,
-        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);
-        this._orderStateUtils = new OrderStateUtils(
-            this._balanceAndProxyAllowanceLazyStore,
-            this._orderFilledCancelledLazyStore,
-        );
-        const orderExpirationCheckingIntervalMsIfExists = _.isUndefined(config)
-            ? undefined
-            : config.orderExpirationCheckingIntervalMs;
-        const expirationMarginIfExistsMs = _.isUndefined(config) ? undefined : config.expirationMarginMs;
-        this._expirationWatcher = new ExpirationWatcher(
-            expirationMarginIfExistsMs,
-            orderExpirationCheckingIntervalMsIfExists,
-        );
-        this._cleanupJobInterval =
-            _.isUndefined(config) || _.isUndefined(config.cleanupJobIntervalMs)
-                ? DEFAULT_CLEANUP_JOB_INTERVAL_MS
-                : config.cleanupJobIntervalMs;
-    }
-    /**
-     * Add an order to the orderStateWatcher. Before the order is added, it's
-     * signature is verified.
-     * @param   signedOrder     The order you wish to start watching.
-     */
-    public addOrder(signedOrder: SignedOrder): void {
-        assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        assert.isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker);
-        this._orderByOrderHash[orderHash] = signedOrder;
-        this._addToDependentOrderHashes(signedOrder, orderHash);
-        const expirationUnixTimestampMs = signedOrder.expirationUnixTimestampSec.times(1000);
-        this._expirationWatcher.addOrder(orderHash, expirationUnixTimestampMs);
-    }
-    /**
-     * Removes an order from the orderStateWatcher
-     * @param   orderHash     The orderHash of the order you wish to stop watching.
-     */
-    public removeOrder(orderHash: string): void {
-        assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
-        const signedOrder = this._orderByOrderHash[orderHash];
-        if (_.isUndefined(signedOrder)) {
-            return; // noop
-        }
-        delete this._orderByOrderHash[orderHash];
-        delete this._orderStateByOrderHashCache[orderHash];
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-        this._removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
-        this._removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, orderHash);
-        this._expirationWatcher.removeOrder(orderHash);
-    }
-    /**
-     * Starts an orderStateWatcher subscription. The callback will be called every time a watched order's
-     * backing blockchain state has changed. This is a call-to-action for the caller to re-validate the order.
-     * @param   callback            Receives the orderHash of the order that should be re-validated, together
-     *                              with all the order-relevant blockchain state needed to re-validate the order.
-     */
-    public subscribe(callback: OnOrderStateChangeCallback): void {
-        assert.isFunction('callback', callback);
-        if (!_.isUndefined(this._callbackIfExists)) {
-            throw new Error(ZeroExError.SubscriptionAlreadyPresent);
-        }
-        this._callbackIfExists = callback;
-        this._eventWatcher.subscribe(this._onEventWatcherCallbackAsync.bind(this));
-        this._expirationWatcher.subscribe(this._onOrderExpired.bind(this));
-        this._cleanupJobIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
-            this._cleanupAsync.bind(this),
-            this._cleanupJobInterval,
-        );
-    }
-    /**
-     * Ends an orderStateWatcher subscription.
-     */
-    public unsubscribe(): void {
-        if (_.isUndefined(this._callbackIfExists) || _.isUndefined(this._cleanupJobIntervalIdIfExists)) {
-            throw new Error(ZeroExError.SubscriptionNotFound);
-        }
-        this._balanceAndProxyAllowanceLazyStore.deleteAll();
-        this._orderFilledCancelledLazyStore.deleteAll();
-        delete this._callbackIfExists;
-        this._eventWatcher.unsubscribe();
-        this._expirationWatcher.unsubscribe();
-        intervalUtils.clearAsyncExcludingInterval(this._cleanupJobIntervalIdIfExists);
-    }
-    private async _cleanupAsync(): Promise<void> {
-        for (const orderHash of _.keys(this._orderByOrderHash)) {
-            this._cleanupOrderRelatedState(orderHash);
-            await this._emitRevalidateOrdersAsync([orderHash]);
-        }
-    }
-    private _cleanupOrderRelatedState(orderHash: string): void {
-        const signedOrder = this._orderByOrderHash[orderHash];
-
-        this._orderFilledCancelledLazyStore.deleteFilledTakerAmount(orderHash);
-        this._orderFilledCancelledLazyStore.deleteCancelledTakerAmount(orderHash);
-
-        this._balanceAndProxyAllowanceLazyStore.deleteBalance(signedOrder.makerTokenAddress, signedOrder.maker);
-        this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(signedOrder.makerTokenAddress, signedOrder.maker);
-        this._balanceAndProxyAllowanceLazyStore.deleteBalance(signedOrder.takerTokenAddress, signedOrder.taker);
-        this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(signedOrder.takerTokenAddress, signedOrder.taker);
-
-        const zrxTokenAddress = this._getZRXTokenAddress();
-        if (!signedOrder.makerFee.isZero()) {
-            this._balanceAndProxyAllowanceLazyStore.deleteBalance(zrxTokenAddress, signedOrder.maker);
-            this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(zrxTokenAddress, signedOrder.maker);
-        }
-        if (!signedOrder.takerFee.isZero()) {
-            this._balanceAndProxyAllowanceLazyStore.deleteBalance(zrxTokenAddress, signedOrder.taker);
-            this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(zrxTokenAddress, signedOrder.taker);
-        }
-    }
-    private _onOrderExpired(orderHash: string): void {
-        const orderState: OrderState = {
-            isValid: false,
-            orderHash,
-            error: ExchangeContractErrs.OrderFillExpired,
-        };
-        if (!_.isUndefined(this._orderByOrderHash[orderHash])) {
-            this.removeOrder(orderHash);
-            if (!_.isUndefined(this._callbackIfExists)) {
-                this._callbackIfExists(orderState);
-            }
-        }
-    }
-    private async _onEventWatcherCallbackAsync(log: LogEvent): Promise<void> {
-        const maybeDecodedLog = this._abiDecoder.tryToDecodeLogOrNoop(log);
-        const isLogDecoded = !_.isUndefined((maybeDecodedLog as LogWithDecodedArgs<any>).event);
-        if (!isLogDecoded) {
-            return; // noop
-        }
-        const decodedLog = maybeDecodedLog as LogWithDecodedArgs<ContractEventArgs>;
-        let makerToken: string;
-        let makerAddress: string;
-        switch (decodedLog.event) {
-            case TokenEvents.Approval: {
-                // Invalidate cache
-                const args = decodedLog.args as ApprovalContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteProxyAllowance(decodedLog.address, args._owner);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case TokenEvents.Transfer: {
-                // Invalidate cache
-                const args = decodedLog.args as TransferContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._from);
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._to);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._from;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case EtherTokenEvents.Deposit: {
-                // Invalidate cache
-                const args = decodedLog.args as DepositContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case EtherTokenEvents.Withdrawal: {
-                // Invalidate cache
-                const args = decodedLog.args as WithdrawalContractEventArgs;
-                this._balanceAndProxyAllowanceLazyStore.deleteBalance(decodedLog.address, args._owner);
-                // Revalidate orders
-                makerToken = decodedLog.address;
-                makerAddress = args._owner;
-                if (
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress]) &&
-                    !_.isUndefined(this._dependentOrderHashes[makerAddress][makerToken])
-                ) {
-                    const orderHashes = Array.from(this._dependentOrderHashes[makerAddress][makerToken]);
-                    await this._emitRevalidateOrdersAsync(orderHashes);
-                }
-                break;
-            }
-            case ExchangeEvents.LogFill: {
-                // Invalidate cache
-                const args = decodedLog.args as LogFillContractEventArgs;
-                this._orderFilledCancelledLazyStore.deleteFilledTakerAmount(args.orderHash);
-                // Revalidate orders
-                const orderHash = args.orderHash;
-                const isOrderWatched = !_.isUndefined(this._orderByOrderHash[orderHash]);
-                if (isOrderWatched) {
-                    await this._emitRevalidateOrdersAsync([orderHash]);
-                }
-                break;
-            }
-            case ExchangeEvents.LogCancel: {
-                // Invalidate cache
-                const args = decodedLog.args as LogCancelContractEventArgs;
-                this._orderFilledCancelledLazyStore.deleteCancelledTakerAmount(args.orderHash);
-                // Revalidate orders
-                const orderHash = args.orderHash;
-                const isOrderWatched = !_.isUndefined(this._orderByOrderHash[orderHash]);
-                if (isOrderWatched) {
-                    await this._emitRevalidateOrdersAsync([orderHash]);
-                }
-                break;
-            }
-            case ExchangeEvents.LogError:
-                return; // noop
-
-            default:
-                throw utils.spawnSwitchErr('decodedLog.event', decodedLog.event);
-        }
-    }
-    private async _emitRevalidateOrdersAsync(orderHashes: string[]): Promise<void> {
-        for (const orderHash of orderHashes) {
-            const signedOrder = this._orderByOrderHash[orderHash];
-            // Most of these calls will never reach the network because the data is fetched from stores
-            // and only updated when cache is invalidated
-            const orderState = await this._orderStateUtils.getOrderStateAsync(signedOrder);
-            if (_.isUndefined(this._callbackIfExists)) {
-                break; // Unsubscribe was called
-            }
-            if (_.isEqual(orderState, this._orderStateByOrderHashCache[orderHash])) {
-                // Actual order state didn't change
-                continue;
-            } else {
-                this._orderStateByOrderHashCache[orderHash] = orderState;
-            }
-            this._callbackIfExists(orderState);
-        }
-    }
-    private _addToDependentOrderHashes(signedOrder: SignedOrder, orderHash: string): void {
-        if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker])) {
-            this._dependentOrderHashes[signedOrder.maker] = {};
-        }
-        if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress])) {
-            this._dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress] = new Set();
-        }
-        this._dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress].add(orderHash);
-        const zrxTokenAddress = this._getZRXTokenAddress();
-        if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress])) {
-            this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress] = new Set();
-        }
-        this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress].add(orderHash);
-    }
-    private _removeFromDependentOrderHashes(makerAddress: string, tokenAddress: string, orderHash: string) {
-        this._dependentOrderHashes[makerAddress][tokenAddress].delete(orderHash);
-        if (this._dependentOrderHashes[makerAddress][tokenAddress].size === 0) {
-            delete this._dependentOrderHashes[makerAddress][tokenAddress];
-        }
-        if (_.isEmpty(this._dependentOrderHashes[makerAddress])) {
-            delete this._dependentOrderHashes[makerAddress];
-        }
-    }
-    private _getZRXTokenAddress(): string {
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-        return zrxTokenAddress;
-    }
-}

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

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

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

@@ -1,27 +0,0 @@
-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,
-                },
-            },
-        },
-    },
-    type: 'object',
-    required: ['networkId'],
-};

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

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

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

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

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

@@ -1,410 +0,0 @@
-import { TransactionReceipt } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import * as Web3 from 'web3';
-
-export enum ZeroExError {
-    ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST',
-    ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST',
-    EtherTokenContractDoesNotExist = 'ETHER_TOKEN_CONTRACT_DOES_NOT_EXIST',
-    TokenTransferProxyContractDoesNotExist = 'TOKEN_TRANSFER_PROXY_CONTRACT_DOES_NOT_EXIST',
-    TokenRegistryContractDoesNotExist = 'TOKEN_REGISTRY_CONTRACT_DOES_NOT_EXIST',
-    TokenContractDoesNotExist = 'TOKEN_CONTRACT_DOES_NOT_EXIST',
-    UnhandledError = 'UNHANDLED_ERROR',
-    UserHasNoAssociatedAddress = 'USER_HAS_NO_ASSOCIATED_ADDRESSES',
-    InvalidSignature = 'INVALID_SIGNATURE',
-    ContractNotDeployedOnNetwork = 'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
-    InsufficientAllowanceForTransfer = 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
-    InsufficientBalanceForTransfer = 'INSUFFICIENT_BALANCE_FOR_TRANSFER',
-    InsufficientEthBalanceForDeposit = 'INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT',
-    InsufficientWEthBalanceForWithdrawal = 'INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWAL',
-    InvalidJump = 'INVALID_JUMP',
-    OutOfGas = 'OUT_OF_GAS',
-    NoNetworkId = 'NO_NETWORK_ID',
-    SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
-    SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
-    TransactionMiningTimeout = 'TRANSACTION_MINING_TIMEOUT',
-}
-
-export enum InternalZeroExError {
-    NoAbiDecoder = 'NO_ABI_DECODER',
-    ZrxNotInTokenRegistry = 'ZRX_NOT_IN_TOKEN_REGISTRY',
-    WethNotInTokenRegistry = 'WETH_NOT_IN_TOKEN_REGISTRY',
-}
-
-/**
- * Elliptic Curve signature
- */
-export interface ECSignature {
-    v: number;
-    r: string;
-    s: string;
-}
-
-export type OrderAddresses = [string, string, string, string, string];
-
-export type OrderValues = [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
-
-export type LogEvent = Web3.LogEntryEvent;
-export interface DecodedLogEvent<ArgsType> {
-    isRemoved: boolean;
-    log: LogWithDecodedArgs<ArgsType>;
-}
-
-export type EventCallback<ArgsType> = (err: null | Error, log?: DecodedLogEvent<ArgsType>) => void;
-export type EventWatcherCallback = (log: LogEvent) => void;
-
-export enum SolidityTypes {
-    Address = 'address',
-    Uint256 = 'uint256',
-    Uint8 = 'uint8',
-    Uint = 'uint',
-}
-
-export enum ExchangeContractErrCodes {
-    ERROR_FILL_EXPIRED, // Order has already expired
-    ERROR_FILL_NO_VALUE, // Order has already been fully filled or cancelled
-    ERROR_FILL_TRUNCATION, // Rounding error too large
-    ERROR_FILL_BALANCE_ALLOWANCE, // Insufficient balance or allowance for token transfer
-    ERROR_CANCEL_EXPIRED, // Order has already expired
-    ERROR_CANCEL_NO_VALUE, // Order has already been fully filled or cancelled
-}
-
-export enum ExchangeContractErrs {
-    OrderFillExpired = 'ORDER_FILL_EXPIRED',
-    OrderCancelExpired = 'ORDER_CANCEL_EXPIRED',
-    OrderCancelAmountZero = 'ORDER_CANCEL_AMOUNT_ZERO',
-    OrderAlreadyCancelledOrFilled = 'ORDER_ALREADY_CANCELLED_OR_FILLED',
-    OrderFillAmountZero = 'ORDER_FILL_AMOUNT_ZERO',
-    OrderRemainingFillAmountZero = 'ORDER_REMAINING_FILL_AMOUNT_ZERO',
-    OrderFillRoundingError = 'ORDER_FILL_ROUNDING_ERROR',
-    FillBalanceAllowanceError = 'FILL_BALANCE_ALLOWANCE_ERROR',
-    InsufficientTakerBalance = 'INSUFFICIENT_TAKER_BALANCE',
-    InsufficientTakerAllowance = 'INSUFFICIENT_TAKER_ALLOWANCE',
-    InsufficientMakerBalance = 'INSUFFICIENT_MAKER_BALANCE',
-    InsufficientMakerAllowance = 'INSUFFICIENT_MAKER_ALLOWANCE',
-    InsufficientTakerFeeBalance = 'INSUFFICIENT_TAKER_FEE_BALANCE',
-    InsufficientTakerFeeAllowance = 'INSUFFICIENT_TAKER_FEE_ALLOWANCE',
-    InsufficientMakerFeeBalance = 'INSUFFICIENT_MAKER_FEE_BALANCE',
-    InsufficientMakerFeeAllowance = 'INSUFFICIENT_MAKER_FEE_ALLOWANCE',
-    TransactionSenderIsNotFillOrderTaker = 'TRANSACTION_SENDER_IS_NOT_FILL_ORDER_TAKER',
-    MultipleMakersInSingleCancelBatchDisallowed = 'MULTIPLE_MAKERS_IN_SINGLE_CANCEL_BATCH_DISALLOWED',
-    InsufficientRemainingFillAmount = 'INSUFFICIENT_REMAINING_FILL_AMOUNT',
-    MultipleTakerTokensInFillUpToDisallowed = 'MULTIPLE_TAKER_TOKENS_IN_FILL_UP_TO_DISALLOWED',
-    BatchOrdersMustHaveSameExchangeAddress = 'BATCH_ORDERS_MUST_HAVE_SAME_EXCHANGE_ADDRESS',
-    BatchOrdersMustHaveAtLeastOneItem = 'BATCH_ORDERS_MUST_HAVE_AT_LEAST_ONE_ITEM',
-}
-
-export type RawLog = Web3.LogEntry;
-
-export interface ContractEvent {
-    logIndex: number;
-    transactionIndex: number;
-    transactionHash: string;
-    blockHash: string;
-    blockNumber: number;
-    address: string;
-    type: string;
-    event: string;
-    args: ContractEventArgs;
-}
-
-export interface LogFillContractEventArgs {
-    maker: string;
-    taker: string;
-    feeRecipient: string;
-    makerToken: string;
-    takerToken: string;
-    filledMakerTokenAmount: BigNumber;
-    filledTakerTokenAmount: BigNumber;
-    paidMakerFee: BigNumber;
-    paidTakerFee: BigNumber;
-    tokens: string;
-    orderHash: string;
-}
-export interface LogCancelContractEventArgs {
-    maker: string;
-    feeRecipient: string;
-    makerToken: string;
-    takerToken: string;
-    cancelledMakerTokenAmount: BigNumber;
-    cancelledTakerTokenAmount: BigNumber;
-    tokens: string;
-    orderHash: string;
-}
-export interface LogErrorContractEventArgs {
-    errorId: BigNumber;
-    orderHash: string;
-}
-export type ExchangeContractEventArgs =
-    | LogFillContractEventArgs
-    | LogCancelContractEventArgs
-    | LogErrorContractEventArgs;
-export interface TransferContractEventArgs {
-    _from: string;
-    _to: string;
-    _value: BigNumber;
-}
-export interface ApprovalContractEventArgs {
-    _owner: string;
-    _spender: string;
-    _value: BigNumber;
-}
-export interface DepositContractEventArgs {
-    _owner: string;
-    _value: BigNumber;
-}
-export interface WithdrawalContractEventArgs {
-    _owner: string;
-    _value: BigNumber;
-}
-export type TokenContractEventArgs = TransferContractEventArgs | ApprovalContractEventArgs;
-export type EtherTokenContractEventArgs =
-    | TokenContractEventArgs
-    | DepositContractEventArgs
-    | WithdrawalContractEventArgs;
-export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs;
-export type ContractEventArg = string | BigNumber;
-
-export interface Order {
-    maker: string;
-    taker: string;
-    makerFee: BigNumber;
-    takerFee: BigNumber;
-    makerTokenAmount: BigNumber;
-    takerTokenAmount: BigNumber;
-    makerTokenAddress: string;
-    takerTokenAddress: string;
-    salt: BigNumber;
-    exchangeContractAddress: string;
-    feeRecipient: string;
-    expirationUnixTimestampSec: BigNumber;
-}
-
-export interface SignedOrder extends Order {
-    ecSignature: ECSignature;
-}
-
-//                          [address, name, symbol, decimals, ipfsHash, swarmHash]
-export type TokenMetadata = [string, string, string, BigNumber, string, string];
-
-export interface Token {
-    name: string;
-    address: string;
-    symbol: string;
-    decimals: number;
-}
-
-export interface TxOpts {
-    from: string;
-    gas?: number;
-    value?: BigNumber;
-    gasPrice?: BigNumber;
-}
-
-export interface TokenAddressBySymbol {
-    [symbol: string]: string;
-}
-
-export enum ExchangeEvents {
-    LogFill = 'LogFill',
-    LogCancel = 'LogCancel',
-    LogError = 'LogError',
-}
-
-export enum TokenEvents {
-    Transfer = 'Transfer',
-    Approval = 'Approval',
-}
-
-export enum EtherTokenEvents {
-    Transfer = 'Transfer',
-    Approval = 'Approval',
-    Deposit = 'Deposit',
-    Withdrawal = 'Withdrawal',
-}
-
-export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents;
-
-export interface IndexedFilterValues {
-    [index: string]: ContractEventArg;
-}
-
-// Earliest is omitted by design. It is simply an alias for the `0` constant and
-// is thus not very helpful. Moreover, this type is used in places that only accept
-// `latest` or `pending`.
-export enum BlockParamLiteral {
-    Latest = 'latest',
-    Pending = 'pending',
-}
-
-export type BlockParam = BlockParamLiteral | number;
-
-export interface BlockRange {
-    fromBlock: BlockParam;
-    toBlock: BlockParam;
-}
-
-export type DoneCallback = (err?: Error) => void;
-
-export interface OrderCancellationRequest {
-    order: Order | SignedOrder;
-    takerTokenCancelAmount: BigNumber;
-}
-
-export interface OrderFillRequest {
-    signedOrder: SignedOrder;
-    takerTokenFillAmount: BigNumber;
-}
-
-export type AsyncMethod = (...args: any[]) => Promise<any>;
-export type SyncMethod = (...args: any[]) => any;
-
-/**
- * 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;
-
-export interface JSONRPCPayload {
-    params: any[];
-    method: string;
-}
-
-/*
- * orderExpirationCheckingIntervalMs: How often to check for expired orders. Default: 50
- * eventPollingIntervalMs: How often to poll the Ethereum node for new events. Defaults: 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
- */
-export interface OrderStateWatcherConfig {
-    orderExpirationCheckingIntervalMs?: number;
-    eventPollingIntervalMs?: number;
-    expirationMarginMs?: number;
-    cleanupJobIntervalMs?: number;
-}
-
-/*
- * networkId: The id of the underlying ethereum network your provider is connected to. (1-mainnet, 42-kovan, 50-testrpc)
- * gasPrice: Gas price to use with every transaction
- * exchangeContractAddress: The address of an exchange contract to use
- * tokenRegistryContractAddress: The address of a token registry contract to use
- * tokenTransferProxyContractAddress: The address of the token transfer proxy contract to use
- * orderWatcherConfig: All the configs related to the orderWatcher
- */
-export interface ZeroExConfig {
-    networkId: number;
-    gasPrice?: BigNumber;
-    exchangeContractAddress?: string;
-    tokenRegistryContractAddress?: string;
-    tokenTransferProxyContractAddress?: string;
-    orderWatcherConfig?: OrderStateWatcherConfig;
-}
-
-export enum AbiType {
-    Function = 'function',
-    Constructor = 'constructor',
-    Event = 'event',
-    Fallback = 'fallback',
-}
-
-export interface DecodedLogArgs {
-    [argName: string]: ContractEventArg;
-}
-
-export interface LogWithDecodedArgs<ArgsType> extends Web3.DecodedLogEntry<ArgsType> {}
-
-export interface TransactionReceiptWithDecodedLogs extends TransactionReceipt {
-    logs: Array<LogWithDecodedArgs<DecodedLogArgs> | Web3.LogEntry>;
-}
-
-export type ArtifactContractName = 'ZRX' | 'TokenTransferProxy' | 'TokenRegistry' | 'Token' | 'Exchange' | 'EtherToken';
-
-export interface Artifact {
-    contract_name: ArtifactContractName;
-    abi: Web3.ContractAbi;
-    networks: {
-        [networkId: number]: {
-            address: string;
-        };
-    };
-}
-
-/*
- * expectedFillTakerTokenAmount: If specified, the validation method will ensure that the
- * supplied order maker has a sufficient allowance/balance to fill this amount of the order's
- * takerTokenAmount. If not specified, the validation method ensures that the maker has a sufficient
- * allowance/balance to fill the entire remaining order amount.
- */
-export interface ValidateOrderFillableOpts {
-    expectedFillTakerTokenAmount?: BigNumber;
-}
-
-/*
- * defaultBlock: The block up to which to query the blockchain state. Setting this to a historical block number
- * let's the user query the blockchain's state at an arbitrary point in time. In order for this to work, the
- * backing  Ethereum node must keep the entire historical state of the chain (e.g setting `--pruning=archive`
- * flag when  running Parity).
- */
-export interface MethodOpts {
-    defaultBlock?: Web3.BlockParam;
-}
-
-/*
- * gasPrice: Gas price in Wei to use for a transaction
- * gasLimit: The amount of gas to send with a transaction
- */
-export interface TransactionOpts {
-    gasPrice?: BigNumber;
-    gasLimit?: number;
-}
-
-/*
- * shouldValidate: Flag indicating whether the library should make attempts to validate a transaction before
- * broadcasting it. For example, order has a valid signature, maker has sufficient funds, etc. Default: true
- */
-export interface OrderTransactionOpts extends TransactionOpts {
-    shouldValidate?: boolean;
-}
-
-export type FilterObject = Web3.FilterObject;
-
-export enum TradeSide {
-    Maker = 'maker',
-    Taker = 'taker',
-}
-
-export enum TransferType {
-    Trade = 'trade',
-    Fee = 'fee',
-}
-
-export interface OrderRelevantState {
-    makerBalance: BigNumber;
-    makerProxyAllowance: BigNumber;
-    makerFeeBalance: BigNumber;
-    makerFeeProxyAllowance: BigNumber;
-    filledTakerTokenAmount: BigNumber;
-    cancelledTakerTokenAmount: BigNumber;
-    remainingFillableMakerTokenAmount: BigNumber;
-    remainingFillableTakerTokenAmount: BigNumber;
-}
-
-export interface OrderStateValid {
-    isValid: true;
-    orderHash: string;
-    orderRelevantState: OrderRelevantState;
-}
-
-export interface OrderStateInvalid {
-    isValid: false;
-    orderHash: string;
-    error: ExchangeContractErrs;
-}
-
-export type OrderState = OrderStateValid | OrderStateInvalid;
-
-export type OnOrderStateChangeCallback = (orderState: OrderState) => void;
-// tslint:disable:max-file-line-count

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

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

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

@@ -1,35 +0,0 @@
-import { assert as sharedAssert } from '@0xproject/assert';
-// We need those two unused imports because they're actually used by sharedAssert which gets injected here
-// tslint:disable-next-line:no-unused-variable
-import { Schema } from '@0xproject/json-schemas';
-// tslint:disable-next-line:no-unused-variable
-import { 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 = {
-    ...sharedAssert,
-    isValidSignature(orderHash: string, ecSignature: ECSignature, signerAddress: string) {
-        const isValidSignature = signatureUtils.isValidSignature(orderHash, ecSignature, signerAddress);
-        this.assert(isValidSignature, `Expected order with hash '${orderHash}' to have a valid signature`);
-    },
-    async isSenderAddressAsync(
-        variableName: string,
-        senderAddressHex: string,
-        web3Wrapper: Web3Wrapper,
-    ): Promise<void> {
-        sharedAssert.isETHAddressHex(variableName, senderAddressHex);
-        const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddressHex);
-        sharedAssert.assert(
-            isSenderAddressAvailable,
-            `Specified ${variableName} ${senderAddressHex} isn't available through the supplied web3 provider`,
-        );
-    },
-    async isUserAddressAvailableAsync(web3Wrapper: Web3Wrapper): Promise<void> {
-        const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
-        this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 provider');
-    },
-};

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

@@ -1,144 +0,0 @@
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
-
-import { ZeroEx } from '../0x';
-import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper';
-import { RemainingFillableCalculator } from '../order_watcher/remaining_fillable_calculator';
-import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store';
-import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store';
-import {
-    ExchangeContractErrs,
-    OrderRelevantState,
-    OrderState,
-    OrderStateInvalid,
-    OrderStateValid,
-    SignedOrder,
-} from '../types';
-
-const ACCEPTABLE_RELATIVE_ROUNDING_ERROR = 0.0001;
-
-export class OrderStateUtils {
-    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
-    private static _validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
-        const unavailableTakerTokenAmount = orderRelevantState.cancelledTakerTokenAmount.add(
-            orderRelevantState.filledTakerTokenAmount,
-        );
-        const availableTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
-        if (availableTakerTokenAmount.eq(0)) {
-            throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
-        }
-
-        if (orderRelevantState.makerBalance.eq(0)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerBalance);
-        }
-        if (orderRelevantState.makerProxyAllowance.eq(0)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerAllowance);
-        }
-        if (!signedOrder.makerFee.eq(0)) {
-            if (orderRelevantState.makerFeeBalance.eq(0)) {
-                throw new Error(ExchangeContractErrs.InsufficientMakerFeeBalance);
-            }
-            if (orderRelevantState.makerFeeProxyAllowance.eq(0)) {
-                throw new Error(ExchangeContractErrs.InsufficientMakerFeeAllowance);
-            }
-        }
-        const minFillableTakerTokenAmountWithinNoRoundingErrorRange = signedOrder.takerTokenAmount
-            .dividedBy(ACCEPTABLE_RELATIVE_ROUNDING_ERROR)
-            .dividedBy(signedOrder.makerTokenAmount);
-        if (
-            orderRelevantState.remainingFillableTakerTokenAmount.lessThan(
-                minFillableTakerTokenAmountWithinNoRoundingErrorRange,
-            )
-        ) {
-            throw new Error(ExchangeContractErrs.OrderFillRoundingError);
-        }
-    }
-    constructor(
-        balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore,
-        orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore,
-    ) {
-        this._balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
-        this._orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
-    }
-    public async getOrderStateAsync(signedOrder: SignedOrder): Promise<OrderState> {
-        const orderRelevantState = await this.getOrderRelevantStateAsync(signedOrder);
-        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        try {
-            OrderStateUtils._validateIfOrderIsValid(signedOrder, orderRelevantState);
-            const orderState: OrderStateValid = {
-                isValid: true,
-                orderHash,
-                orderRelevantState,
-            };
-            return orderState;
-        } catch (err) {
-            const orderState: OrderStateInvalid = {
-                isValid: false,
-                orderHash,
-                error: err.message,
-            };
-            return orderState;
-        }
-    }
-    public async getOrderRelevantStateAsync(signedOrder: SignedOrder): Promise<OrderRelevantState> {
-        // HACK: We access the private property here but otherwise the interface will be less nice.
-        // If we pass it from the instantiator - there is no opportunity to get it there
-        // because JS doesn't support async constructors.
-        // Moreover - it's cached under the hood so it's equivalent to an async constructor.
-        const exchange = (this._orderFilledCancelledLazyStore as any)._exchange as ExchangeWrapper;
-        const zrxTokenAddress = exchange.getZRXTokenAddress();
-        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        const makerBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
-        );
-        const makerProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
-            signedOrder.makerTokenAddress,
-            signedOrder.maker,
-        );
-        const makerFeeBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
-            zrxTokenAddress,
-            signedOrder.maker,
-        );
-        const makerFeeProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
-            zrxTokenAddress,
-            signedOrder.maker,
-        );
-        const filledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
-        const cancelledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
-            orderHash,
-        );
-        const unavailableTakerTokenAmount = await exchange.getUnavailableTakerAmountAsync(orderHash);
-        const totalMakerTokenAmount = signedOrder.makerTokenAmount;
-        const totalTakerTokenAmount = signedOrder.takerTokenAmount;
-        const remainingTakerTokenAmount = totalTakerTokenAmount.minus(unavailableTakerTokenAmount);
-        const remainingMakerTokenAmount = remainingTakerTokenAmount
-            .times(totalMakerTokenAmount)
-            .dividedToIntegerBy(totalTakerTokenAmount);
-        const transferrableMakerTokenAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
-        const transferrableFeeTokenAmount = BigNumber.min([makerFeeProxyAllowance, makerFeeBalance]);
-
-        const isMakerTokenZRX = signedOrder.makerTokenAddress === zrxTokenAddress;
-        const remainingFillableCalculator = new RemainingFillableCalculator(
-            signedOrder,
-            isMakerTokenZRX,
-            transferrableMakerTokenAmount,
-            transferrableFeeTokenAmount,
-            remainingMakerTokenAmount,
-        );
-        const remainingFillableMakerTokenAmount = remainingFillableCalculator.computeRemainingMakerFillable();
-        const remainingFillableTakerTokenAmount = remainingFillableCalculator.computeRemainingTakerFillable();
-        const orderRelevantState = {
-            makerBalance,
-            makerProxyAllowance,
-            makerFeeBalance,
-            makerFeeProxyAllowance,
-            filledTakerTokenAmount,
-            cancelledTakerTokenAmount,
-            remainingFillableMakerTokenAmount,
-            remainingFillableTakerTokenAmount,
-        };
-        return orderRelevantState;
-    }
-}

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

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

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

@@ -1,46 +0,0 @@
-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);
-        const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff);
-        try {
-            const pubKey = ethUtil.ecrecover(
-                msgHashBuff,
-                signature.v,
-                ethUtil.toBuffer(signature.r),
-                ethUtil.toBuffer(signature.s),
-            );
-            const retrievedAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
-            return retrievedAddress === signerAddress;
-        } catch (err) {
-            return false;
-        }
-    },
-    parseSignatureHexAsVRS(signatureHex: string): ECSignature {
-        const signatureBuffer = ethUtil.toBuffer(signatureHex);
-        let v = signatureBuffer[0];
-        if (v < 27) {
-            v += 27;
-        }
-        const r = signatureBuffer.slice(1, 33);
-        const s = signatureBuffer.slice(33, 65);
-        const ecSignature: ECSignature = {
-            v,
-            r: ethUtil.bufferToHex(r),
-            s: ethUtil.bufferToHex(s),
-        };
-        return ecSignature;
-    },
-    parseSignatureHexAsRSV(signatureHex: string): ECSignature {
-        const { v, r, s } = ethUtil.fromRpcSig(signatureHex);
-        const ecSignature: ECSignature = {
-            v,
-            r: ethUtil.bufferToHex(r),
-            s: ethUtil.bufferToHex(s),
-        };
-        return ecSignature;
-    },
-};

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

@@ -1,74 +0,0 @@
-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, SolidityTypes } from '../types';
-
-export const utils = {
-    /**
-     * Converts BigNumber instance to BN
-     * The only reason we convert to BN is to remain compatible with `ethABI. soliditySHA3` that
-     * expects values of Solidity type `uint` to be passed as type `BN`.
-     * We do not use BN anywhere else in the codebase.
-     */
-    bigNumberToBN(value: BigNumber) {
-        return new BN(value.toString(), 10);
-    },
-    consoleLog(message: string): void {
-        // tslint:disable-next-line: no-console
-        console.log(message);
-    },
-    isParityNode(nodeVersion: string): boolean {
-        return _.includes(nodeVersion, 'Parity');
-    },
-    isTestRpc(nodeVersion: string): boolean {
-        return _.includes(nodeVersion, 'TestRPC');
-    },
-    spawnSwitchErr(name: string, value: any): Error {
-        return new Error(`Unexpected switch value: ${value} encountered for ${name}`);
-    },
-    getOrderHashHex(order: Order | SignedOrder): string {
-        const orderParts = [
-            { value: order.exchangeContractAddress, type: SolidityTypes.Address },
-            { value: order.maker, type: SolidityTypes.Address },
-            { value: order.taker, type: SolidityTypes.Address },
-            { value: order.makerTokenAddress, type: SolidityTypes.Address },
-            { value: order.takerTokenAddress, type: SolidityTypes.Address },
-            { value: order.feeRecipient, type: SolidityTypes.Address },
-            {
-                value: utils.bigNumberToBN(order.makerTokenAmount),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.takerTokenAmount),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.makerFee),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.takerFee),
-                type: SolidityTypes.Uint256,
-            },
-            {
-                value: utils.bigNumberToBN(order.expirationUnixTimestampSec),
-                type: SolidityTypes.Uint256,
-            },
-            { value: utils.bigNumberToBN(order.salt), type: SolidityTypes.Uint256 },
-        ];
-        const types = _.map(orderParts, o => o.type);
-        const values = _.map(orderParts, o => o.value);
-        const hashBuff = ethABI.soliditySHA3(types, values);
-        const hashHex = ethUtil.bufferToHex(hashBuff);
-        return hashHex;
-    },
-    getCurrentUnixTimestampSec(): BigNumber {
-        return new BigNumber(Date.now() / 1000).round();
-    },
-    getCurrentUnixTimestampMs(): BigNumber {
-        return new BigNumber(Date.now());
-    },
-};

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

@@ -1,282 +0,0 @@
-import { BlockchainLifecycle } 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 { ApprovalContractEventArgs, LogWithDecodedArgs, Order, TokenEvents, ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { TokenUtils } from './utils/token_utils';
-import { web3Factory } from './utils/web3_factory';
-
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-chaiSetup.configure();
-const expect = chai.expect;
-
-describe('ZeroEx library', () => {
-    const web3 = web3Factory.create();
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
-    describe('#setProvider', () => {
-        it('overrides provider in nested web3s and invalidates contractInstances', async () => {
-            // Instantiate the contract instances with the current provider
-            await (zeroEx.exchange as any)._getExchangeContractAsync();
-            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-            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);
-
-            // 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();
-            expect(nestedWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
-            expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getCurrentProvider();
-            expect(tokenRegistryWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-        });
-    });
-    describe('#isValidSignature', () => {
-        // The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes
-        // the length of the data is exactly 32 bytes. Thus for these tests, we use data of this size.
-        const dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-        const signature = {
-            v: 27,
-            r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-            s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-        };
-        const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-        it("should return false if the data doesn't pertain to the signature & address", async () => {
-            expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync('0x0', signature, address),
-            ).to.become(false);
-        });
-        it("should return false if the address doesn't pertain to the signature & data", async () => {
-            const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
-            expect(ZeroEx.isValidSignature(dataHex, signature, validUnrelatedAddress)).to.be.false();
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(
-                    dataHex,
-                    signature,
-                    validUnrelatedAddress,
-                ),
-            ).to.become(false);
-        });
-        it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
-            const wrongSignature = _.assign({}, signature, { v: 28 });
-            expect(ZeroEx.isValidSignature(dataHex, wrongSignature, address)).to.be.false();
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, wrongSignature, address),
-            ).to.become(false);
-        });
-        it('should return true if the signature does pertain to the dataHex & address', async () => {
-            const isValidSignatureLocal = ZeroEx.isValidSignature(dataHex, signature, address);
-            expect(isValidSignatureLocal).to.be.true();
-            return expect(
-                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature, address),
-            ).to.become(true);
-        });
-    });
-    describe('#generateSalt', () => {
-        it('generates different salts', () => {
-            const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt());
-            expect(equal).to.be.false();
-        });
-        it('generates salt in range [0..2^256)', () => {
-            const salt = ZeroEx.generatePseudoRandomSalt();
-            expect(salt.greaterThanOrEqualTo(0)).to.be.true();
-            const twoPow256 = new BigNumber(2).pow(256);
-            expect(salt.lessThan(twoPow256)).to.be.true();
-        });
-    });
-    describe('#isValidOrderHash', () => {
-        it('returns false if the value is not a hex string', () => {
-            const isValid = ZeroEx.isValidOrderHash('not a hex');
-            expect(isValid).to.be.false();
-        });
-        it('returns false if the length is wrong', () => {
-            const isValid = ZeroEx.isValidOrderHash('0xdeadbeef');
-            expect(isValid).to.be.false();
-        });
-        it('returns true if order hash is correct', () => {
-            const isValid = ZeroEx.isValidOrderHash('0x' + Array(65).join('0'));
-            expect(isValid).to.be.true();
-        });
-    });
-    describe('#toUnitAmount', () => {
-        it('should throw if invalid baseUnit amount supplied as argument', () => {
-            const invalidBaseUnitAmount = new BigNumber(1000000000.4);
-            const decimals = 6;
-            expect(() => ZeroEx.toUnitAmount(invalidBaseUnitAmount, decimals)).to.throw(
-                'amount should be in baseUnits (no decimals), found value: 1000000000.4',
-            );
-        });
-        it('Should return the expected unit amount for the decimals passed in', () => {
-            const baseUnitAmount = new BigNumber(1000000000);
-            const decimals = 6;
-            const unitAmount = ZeroEx.toUnitAmount(baseUnitAmount, decimals);
-            const expectedUnitAmount = new BigNumber(1000);
-            expect(unitAmount).to.be.bignumber.equal(expectedUnitAmount);
-        });
-    });
-    describe('#toBaseUnitAmount', () => {
-        it('Should return the expected base unit amount for the decimals passed in', () => {
-            const unitAmount = new BigNumber(1000);
-            const decimals = 6;
-            const baseUnitAmount = ZeroEx.toBaseUnitAmount(unitAmount, decimals);
-            const expectedUnitAmount = new BigNumber(1000000000);
-            expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount);
-        });
-        it('should throw if unitAmount has more decimals then specified as the max decimal precision', () => {
-            const unitAmount = new BigNumber(0.823091);
-            const decimals = 5;
-            expect(() => ZeroEx.toBaseUnitAmount(unitAmount, decimals)).to.throw(
-                'Invalid unit amount: 0.823091 - Too many decimal places',
-            );
-        });
-    });
-    describe('#getOrderHashHex', () => {
-        const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
-        const fakeExchangeContractAddress = '0xb69e673309512a9d726f87304c6984054f87a93b';
-        const order: Order = {
-            maker: constants.NULL_ADDRESS,
-            taker: constants.NULL_ADDRESS,
-            feeRecipient: constants.NULL_ADDRESS,
-            makerTokenAddress: constants.NULL_ADDRESS,
-            takerTokenAddress: constants.NULL_ADDRESS,
-            exchangeContractAddress: fakeExchangeContractAddress,
-            salt: new BigNumber(0),
-            makerFee: new BigNumber(0),
-            takerFee: new BigNumber(0),
-            makerTokenAmount: new BigNumber(0),
-            takerTokenAmount: new BigNumber(0),
-            expirationUnixTimestampSec: new BigNumber(0),
-        };
-        it('calculates the order hash', async () => {
-            const orderHash = ZeroEx.getOrderHashHex(order);
-            expect(orderHash).to.be.equal(expectedOrderHash);
-        });
-        it('throws a readable error message if taker format is invalid', async () => {
-            const orderWithInvalidtakerFormat = {
-                ...order,
-                taker: (null as any) as string,
-            };
-            const expectedErrorMessage =
-                'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
-            expect(() => ZeroEx.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
-        });
-    });
-    describe('#signOrderHashAsync', () => {
-        let stubs: Sinon.SinonStub[] = [];
-        let makerAddress: string;
-        before(async () => {
-            const availableAddreses = await zeroEx.getAvailableAddressesAsync();
-            makerAddress = availableAddreses[0];
-        });
-        afterEach(() => {
-            // clean up any stubs after the test has completed
-            _.each(stubs, s => s.restore());
-            stubs = [];
-        });
-        it('Should return the correct ECSignature', async () => {
-            const orderHash = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-            const expectedECSignature = {
-                v: 27,
-                r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-                s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-            };
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-        it('should return the correct ECSignature for signatureHex concatenated as R + S + V', async () => {
-            const orderHash = '0x34decbedc118904df65f379a175bb39ca18209d6ce41d5ed549d54e6e0a95004';
-            const signature =
-                '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb021b';
-            const expectedECSignature = {
-                v: 27,
-                r: '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3',
-                s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
-            };
-            stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
-                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-            ];
-
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-        it('should return the correct ECSignature for signatureHex concatenated as V + R + S', async () => {
-            const orderHash = '0xc793e33ffded933b76f2f48d9aa3339fc090399d5e7f5dec8d3660f5480793f7';
-            const signature =
-                '0x1bc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee02dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960';
-            const expectedECSignature = {
-                v: 27,
-                r: '0xc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee0',
-                s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
-            };
-            stubs = [
-                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
-                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-            ];
-
-            const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);
-            expect(ecSignature).to.deep.equal(expectedECSignature);
-        });
-    });
-    describe('#awaitTransactionMinedAsync', () => {
-        beforeEach(async () => {
-            await blockchainLifecycle.startAsync();
-        });
-        afterEach(async () => {
-            await blockchainLifecycle.revertAsync();
-        });
-        it('returns transaction receipt with decoded logs', async () => {
-            const availableAddresses = await zeroEx.getAvailableAddressesAsync();
-            const coinbase = availableAddresses[0];
-            const tokens = await zeroEx.tokenRegistry.getTokensAsync();
-            const tokenUtils = new TokenUtils(tokens);
-            const zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-            const proxyAddress = zeroEx.proxy.getContractAddress();
-            const txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
-            const txReceiptWithDecodedLogs = await zeroEx.awaitTransactionMinedAsync(txHash);
-            const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ApprovalContractEventArgs>;
-            expect(log.event).to.be.equal(TokenEvents.Approval);
-            expect(log.args._owner).to.be.equal(coinbase);
-            expect(log.args._spender).to.be.equal(proxyAddress);
-            expect(log.args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-        });
-    });
-    describe('#config', () => {
-        it('allows to specify exchange contract address', async () => {
-            const zeroExConfig = {
-                exchangeContractAddress: ZeroEx.NULL_ADDRESS,
-                networkId: constants.TESTRPC_NETWORK_ID,
-            };
-            const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-            expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
-        });
-        it('allows to specify token registry token contract address', async () => {
-            const zeroExConfig = {
-                tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
-                networkId: constants.TESTRPC_NETWORK_ID,
-            };
-            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-            expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
-                ZeroEx.NULL_ADDRESS,
-            );
-        });
-    });
-});

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

@@ -1,55 +0,0 @@
-import * as fs from 'fs';
-import HDWalletProvider = require('truffle-hdwallet-provider');
-
-import { ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-
-chaiSetup.configure();
-
-// Those tests are slower cause they're talking to a remote node
-const TIMEOUT = 10000;
-
-describe('Artifacts', () => {
-    describe('contracts are deployed on kovan', () => {
-        const kovanRpcUrl = constants.KOVAN_RPC_URL;
-        const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
-        const packageJSON = JSON.parse(packageJSONContent);
-        const mnemonic = packageJSON.config.mnemonic;
-        const web3Provider = new HDWalletProvider(mnemonic, kovanRpcUrl);
-        const config = {
-            networkId: constants.KOVAN_NETWORK_ID,
-        };
-        const zeroEx = new ZeroEx(web3Provider, config);
-        it('token registry contract is deployed', async () => {
-            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-        }).timeout(TIMEOUT);
-        it('proxy contract is deployed', async () => {
-            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
-        }).timeout(TIMEOUT);
-        it('exchange contract is deployed', async () => {
-            await (zeroEx.exchange as any)._getExchangeContractAsync();
-        }).timeout(TIMEOUT);
-    });
-    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 config = {
-            networkId: constants.ROPSTEN_NETWORK_ID,
-        };
-        const zeroEx = new ZeroEx(web3Provider, config);
-        it('token registry contract is deployed', async () => {
-            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-        }).timeout(TIMEOUT);
-        it('proxy contract is deployed', async () => {
-            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
-        }).timeout(TIMEOUT);
-        it('exchange contract is deployed', async () => {
-            await (zeroEx.exchange as any)._getExchangeContractAsync();
-        }).timeout(TIMEOUT);
-    });
-});

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

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

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

@@ -1,123 +0,0 @@
-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';
-import { DoneCallback } from '../src/types';
-
-import { chaiSetup } from './utils/chai_setup';
-import { web3Factory } from './utils/web3_factory';
-
-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 = {
-        address: '0x71d271f8b14adef568f8f28f1587ce7271ac4ca5',
-        blockHash: null,
-        blockNumber: null,
-        data: '',
-        logIndex: null,
-        topics: [],
-        transactionHash: '0x004881d38cd4a8f72f1a0d68c8b9b8124504706041ff37019c1d1ed6bfda8e17',
-        transactionIndex: 0,
-    };
-    const logB: Web3.LogEntry = {
-        address: '0x8d12a197cb00d4747a1fe03395095ce2a5cc6819',
-        blockHash: null,
-        blockNumber: null,
-        data: '',
-        logIndex: null,
-        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
-        transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
-        transactionIndex: 0,
-    };
-    const logC: Web3.LogEntry = {
-        address: '0x1d271f8b174adef58f1587ce68f8f27271ac4ca5',
-        blockHash: null,
-        blockNumber: null,
-        data: '',
-        logIndex: null,
-        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
-        transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
-        transactionIndex: 0,
-    };
-    before(async () => {
-        web3 = web3Factory.create();
-        const pollingIntervalMs = 10;
-        web3Wrapper = new Web3Wrapper(web3.currentProvider);
-        eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalMs);
-    });
-    afterEach(() => {
-        // clean up any stubs after the test has completed
-        _.each(stubs, s => s.restore());
-        stubs = [];
-        eventWatcher.unsubscribe();
-    });
-    it('correctly emits initial log events', (done: DoneCallback) => {
-        const logs: Web3.LogEntry[] = [logA, logB];
-        const expectedLogEvents = [
-            {
-                removed: false,
-                ...logA,
-            },
-            {
-                removed: false,
-                ...logB,
-            },
-        ];
-        const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
-        getLogsStub.onCall(0).returns(logs);
-        stubs.push(getLogsStub);
-        const callback = (event: LogEvent) => {
-            const expectedLogEvent = expectedLogEvents.shift();
-            expect(event).to.be.deep.equal(expectedLogEvent);
-            if (_.isEmpty(expectedLogEvents)) {
-                done();
-            }
-        };
-        eventWatcher.subscribe(callback);
-    });
-    it('correctly computes the difference and emits only changes', (done: DoneCallback) => {
-        const initialLogs: Web3.LogEntry[] = [logA, logB];
-        const changedLogs: Web3.LogEntry[] = [logA, logC];
-        const expectedLogEvents = [
-            {
-                removed: false,
-                ...logA,
-            },
-            {
-                removed: false,
-                ...logB,
-            },
-            {
-                removed: true,
-                ...logB,
-            },
-            {
-                removed: false,
-                ...logC,
-            },
-        ];
-        const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
-        getLogsStub.onCall(0).returns(initialLogs);
-        getLogsStub.onCall(1).returns(changedLogs);
-        stubs.push(getLogsStub);
-        const callback = (event: LogEvent) => {
-            const expectedLogEvent = expectedLogEvents.shift();
-            expect(event).to.be.deep.equal(expectedLogEvent);
-            if (_.isEmpty(expectedLogEvents)) {
-                done();
-            }
-        };
-        eventWatcher.subscribe(callback);
-    });
-});

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

@@ -1,117 +0,0 @@
-import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { BigNumber } from '@0xproject/utils';
-import * as chai from 'chai';
-
-import { ExchangeContractErrs, Token, ZeroEx } from '../src';
-import { BlockParamLiteral, TradeSide, TransferType } from '../src/types';
-import { ExchangeTransferSimulator } from '../src/utils/exchange_transfer_simulator';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { web3Factory } from './utils/web3_factory';
-
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-
-describe('ExchangeTransferSimulator', () => {
-    const web3 = web3Factory.create();
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    const zeroEx = new ZeroEx(web3.currentProvider, config);
-    const transferAmount = new BigNumber(5);
-    let userAddresses: string[];
-    let tokens: Token[];
-    let coinbase: string;
-    let sender: string;
-    let recipient: string;
-    let exampleTokenAddress: string;
-    let exchangeTransferSimulator: ExchangeTransferSimulator;
-    let txHash: string;
-    before(async () => {
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        [coinbase, sender, recipient] = userAddresses;
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        exampleTokenAddress = tokens[0].address;
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    describe('#transferFromAsync', () => {
-        beforeEach(() => {
-            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
-        });
-        it("throws if the user doesn't have enough allowance", async () => {
-            return expect(
-                exchangeTransferSimulator.transferFromAsync(
-                    exampleTokenAddress,
-                    sender,
-                    recipient,
-                    transferAmount,
-                    TradeSide.Taker,
-                    TransferType.Trade,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
-        });
-        it("throws if the user doesn't have enough balance", async () => {
-            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            return expect(
-                exchangeTransferSimulator.transferFromAsync(
-                    exampleTokenAddress,
-                    sender,
-                    recipient,
-                    transferAmount,
-                    TradeSide.Maker,
-                    TransferType.Trade,
-                ),
-            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
-        });
-        it('updates balances and proxyAllowance after transfer', async () => {
-            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            await exchangeTransferSimulator.transferFromAsync(
-                exampleTokenAddress,
-                sender,
-                recipient,
-                transferAmount,
-                TradeSide.Taker,
-                TransferType.Trade,
-            );
-            const store = (exchangeTransferSimulator as any)._store;
-            const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
-            const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
-            const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
-            expect(senderBalance).to.be.bignumber.equal(0);
-            expect(recipientBalance).to.be.bignumber.equal(transferAmount);
-            expect(senderProxyAllowance).to.be.bignumber.equal(0);
-        });
-        it("doesn't update proxyAllowance after transfer if unlimited", async () => {
-            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(exampleTokenAddress, sender);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            await exchangeTransferSimulator.transferFromAsync(
-                exampleTokenAddress,
-                sender,
-                recipient,
-                transferAmount,
-                TradeSide.Taker,
-                TransferType.Trade,
-            );
-            const store = (exchangeTransferSimulator as any)._store;
-            const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
-            const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
-            const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
-            expect(senderBalance).to.be.bignumber.equal(0);
-            expect(recipientBalance).to.be.bignumber.equal(transferAmount);
-            expect(senderProxyAllowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-        });
-    });
-});

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

@@ -1,160 +0,0 @@
-import { BlockchainLifecycle } 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 as testConstants } from './utils/constants';
-import { FillScenarios } from './utils/fill_scenarios';
-import { reportNoErrorCallbackErrors } from './utils/report_callback_errors';
-import { TokenUtils } from './utils/token_utils';
-import { web3Factory } from './utils/web3_factory';
-
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(testConstants.RPC_URL);
-
-describe('ExpirationWatcher', () => {
-    let web3: Web3;
-    let zeroEx: ZeroEx;
-    let tokenUtils: TokenUtils;
-    let tokens: Token[];
-    let userAddresses: string[];
-    let zrxTokenAddress: string;
-    let fillScenarios: FillScenarios;
-    let exchangeContractAddress: string;
-    let makerTokenAddress: string;
-    let takerTokenAddress: string;
-    let coinbase: string;
-    let makerAddress: string;
-    let takerAddress: string;
-    let feeRecipient: string;
-    const fillableAmount = new BigNumber(5);
-    let currentUnixTimestampSec: BigNumber;
-    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);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        tokenUtils = new TokenUtils(tokens);
-        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-        [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-        makerTokenAddress = makerToken.address;
-        takerTokenAddress = takerToken.address;
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-        const sinonTimerConfig = { shouldAdvanceTime: true } as any;
-        // This constructor has incorrect types
-        timer = Sinon.useFakeTimers(sinonTimerConfig);
-        currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
-        expirationWatcher = new ExpirationWatcher();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-        timer.restore();
-        expirationWatcher.unsubscribe();
-    });
-    it('correctly emits events when order expires', (done: DoneCallback) => {
-        (async () => {
-            const orderLifetimeSec = 60;
-            const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
-            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                expirationUnixTimestampSec,
-            );
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-            const callbackAsync = reportNoErrorCallbackErrors(done)((hash: string) => {
-                expect(hash).to.be.equal(orderHash);
-                expect(utils.getCurrentUnixTimestampSec()).to.be.bignumber.gte(expirationUnixTimestampSec);
-            });
-            expirationWatcher.subscribe(callbackAsync);
-            timer.tick(orderLifetimeSec * 1000);
-        })().catch(done);
-    });
-    it("doesn't emit events before order expires", (done: DoneCallback) => {
-        (async () => {
-            const orderLifetimeSec = 60;
-            const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
-            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                expirationUnixTimestampSec,
-            );
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-            const callbackAsync = reportNoErrorCallbackErrors(done)(async (hash: string) => {
-                done(new Error('Emitted expiration went before the order actually expired'));
-            });
-            expirationWatcher.subscribe(callbackAsync);
-            const notEnoughTime = orderLifetimeSec - 1;
-            timer.tick(notEnoughTime * 1000);
-            done();
-        })().catch(done);
-    });
-    it('emits events in correct order', (done: DoneCallback) => {
-        (async () => {
-            const order1Lifetime = 60;
-            const order2Lifetime = 120;
-            const order1ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order1Lifetime);
-            const order2ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order2Lifetime);
-            const signedOrder1 = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                order1ExpirationUnixTimestampSec,
-            );
-            const signedOrder2 = await fillScenarios.createFillableSignedOrderAsync(
-                makerTokenAddress,
-                takerTokenAddress,
-                makerAddress,
-                takerAddress,
-                fillableAmount,
-                order2ExpirationUnixTimestampSec,
-            );
-            const orderHash1 = ZeroEx.getOrderHashHex(signedOrder1);
-            const orderHash2 = ZeroEx.getOrderHashHex(signedOrder2);
-            expirationWatcher.addOrder(orderHash2, signedOrder2.expirationUnixTimestampSec.times(1000));
-            expirationWatcher.addOrder(orderHash1, signedOrder1.expirationUnixTimestampSec.times(1000));
-            const expirationOrder = [orderHash1, orderHash2];
-            const expectToBeCalledOnce = false;
-            const callbackAsync = reportNoErrorCallbackErrors(done, expectToBeCalledOnce)((hash: string) => {
-                const orderHash = expirationOrder.shift();
-                expect(hash).to.be.equal(orderHash);
-                if (_.isEmpty(expirationOrder)) {
-                    done();
-                }
-            });
-            expirationWatcher.subscribe(callbackAsync);
-            timer.tick(order2Lifetime * 1000);
-        })().catch(done);
-    });
-});

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

@@ -1,558 +0,0 @@
-import { BlockchainLifecycle } 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,
-    OrderState,
-    OrderStateInvalid,
-    OrderStateValid,
-    SignedOrder,
-    Token,
-    ZeroEx,
-    ZeroExError,
-} from '../src';
-import { DoneCallback } from '../src/types';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { FillScenarios } from './utils/fill_scenarios';
-import { reportNoErrorCallbackErrors } from './utils/report_callback_errors';
-import { TokenUtils } from './utils/token_utils';
-import { web3Factory } from './utils/web3_factory';
-
-const TIMEOUT_MS = 150;
-
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-
-describe('OrderStateWatcher', () => {
-    let web3: Web3;
-    let zeroEx: ZeroEx;
-    let tokens: Token[];
-    let tokenUtils: TokenUtils;
-    let fillScenarios: FillScenarios;
-    let userAddresses: string[];
-    let zrxTokenAddress: string;
-    let exchangeContractAddress: string;
-    let makerToken: Token;
-    let takerToken: Token;
-    let maker: string;
-    let taker: string;
-    let signedOrder: SignedOrder;
-    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);
-        exchangeContractAddress = zeroEx.exchange.getContractAddress();
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        [, maker, taker] = userAddresses;
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        tokenUtils = new TokenUtils(tokens);
-        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-        await fillScenarios.initTokenBalancesAsync();
-        [makerToken, takerToken] = tokenUtils.getDummyTokens();
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    describe('#removeOrder', async () => {
-        it('should successfully remove existing order', async () => {
-            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerToken.address,
-                takerToken.address,
-                maker,
-                taker,
-                fillableAmount,
-            );
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            zeroEx.orderStateWatcher.addOrder(signedOrder);
-            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.include({
-                [orderHash]: signedOrder,
-            });
-            let dependentOrderHashes = (zeroEx.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({
-                [orderHash]: signedOrder,
-            });
-            dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
-            expect(dependentOrderHashes[signedOrder.maker]).to.be.undefined();
-        });
-        it('should no-op when removing a non-existing order', async () => {
-            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                makerToken.address,
-                takerToken.address,
-                maker,
-                taker,
-                fillableAmount,
-            );
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            const nonExistentOrderHash = `0x${orderHash
-                .substr(2)
-                .split('')
-                .reverse()
-                .join('')}`;
-            zeroEx.orderStateWatcher.removeOrder(nonExistentOrderHash);
-        });
-    });
-    describe('#subscribe', async () => {
-        afterEach(async () => {
-            zeroEx.orderStateWatcher.unsubscribe();
-        });
-        it('should fail when trying to subscribe twice', async () => {
-            zeroEx.orderStateWatcher.subscribe(_.noop);
-            expect(() => zeroEx.orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
-        });
-    });
-    describe('tests with cleanup', async () => {
-        afterEach(async () => {
-            zeroEx.orderStateWatcher.unsubscribe();
-            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-            zeroEx.orderStateWatcher.removeOrder(orderHash);
-        });
-        it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNoErrorCallbackErrors(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);
-                await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
-            })().catch(done);
-        });
-        it('should not emit an orderState event when irrelevant Transfer event received', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    throw new Error('OrderState callback fired for irrelevant order');
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-                const notTheMaker = userAddresses[0];
-                const anyRecipient = taker;
-                const transferAmount = new BigNumber(2);
-                await zeroEx.token.transferAsync(makerToken.address, notTheMaker, anyRecipient, transferAmount);
-                setTimeout(() => {
-                    done();
-                }, TIMEOUT_MS);
-            })().catch(done);
-        });
-        it('should emit orderStateInvalid when maker moves balance backing watched order', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-                const callback = reportNoErrorCallbackErrors(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);
-                const anyRecipient = taker;
-                const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
-                await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
-            })().catch(done);
-        });
-        it('should emit orderStateInvalid when watched order fully filled', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    expect(orderState.isValid).to.be.false();
-                    const invalidOrderState = orderState as OrderStateInvalid;
-                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-
-                const shouldThrowOnInsufficientBalanceOrAllowance = true;
-                await zeroEx.exchange.fillOrderAsync(
-                    signedOrder,
-                    fillableAmount,
-                    shouldThrowOnInsufficientBalanceOrAllowance,
-                    taker,
-                );
-            })().catch(done);
-        });
-        it('should emit orderStateValid when watched order partially filled', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-
-                const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
-                const fillAmountInBaseUnits = new BigNumber(2);
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    expect(orderState.isValid).to.be.true();
-                    const validOrderState = orderState as OrderStateValid;
-                    expect(validOrderState.orderHash).to.be.equal(orderHash);
-                    const orderRelevantState = validOrderState.orderRelevantState;
-                    const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
-                    const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
-                    expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                        remainingFillable,
-                    );
-                    expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                        remainingFillable,
-                    );
-                    expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-                const shouldThrowOnInsufficientBalanceOrAllowance = true;
-                await zeroEx.exchange.fillOrderAsync(
-                    signedOrder,
-                    fillAmountInBaseUnits,
-                    shouldThrowOnInsufficientBalanceOrAllowance,
-                    taker,
-                );
-            })().catch(done);
-        });
-        it('should trigger the callback when orders backing ZRX allowance changes', (done: DoneCallback) => {
-            (async () => {
-                const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
-                const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), 18);
-                signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    makerFee,
-                    takerFee,
-                    maker,
-                    taker,
-                    fillableAmount,
-                    taker,
-                );
-                const callback = reportNoErrorCallbackErrors(done)();
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-                zeroEx.orderStateWatcher.subscribe(callback);
-                await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, new BigNumber(0));
-            })().catch(done);
-        });
-        describe('remainingFillable(M|T)akerTokenAmount', () => {
-            it('should calculate correct remaining fillable', (done: DoneCallback) => {
-                (async () => {
-                    const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), decimals);
-                    const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), decimals);
-                    signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        makerFillableAmount,
-                        takerFillableAmount,
-                    );
-                    const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-                    const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        expect(orderState.isValid).to.be.true();
-                        const validOrderState = orderState as OrderStateValid;
-                        expect(validOrderState.orderHash).to.be.equal(orderHash);
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            ZeroEx.toBaseUnitAmount(new BigNumber(16), decimals),
-                        );
-                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            ZeroEx.toBaseUnitAmount(new BigNumber(8), decimals),
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    const shouldThrowOnInsufficientBalanceOrAllowance = true;
-                    await zeroEx.exchange.fillOrderAsync(
-                        signedOrder,
-                        fillAmountInBaseUnits,
-                        shouldThrowOnInsufficientBalanceOrAllowance,
-                        taker,
-                    );
-                })().catch(done);
-            });
-            it('should equal approved amount when approved amount is lowest', (done: DoneCallback) => {
-                (async () => {
-                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        fillableAmount,
-                    );
-
-                    const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            changedMakerApprovalAmount,
-                        );
-                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            changedMakerApprovalAmount,
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, changedMakerApprovalAmount);
-                })().catch(done);
-            });
-            it('should equal balance amount when balance amount is lowest', (done: DoneCallback) => {
-                (async () => {
-                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        maker,
-                        taker,
-                        fillableAmount,
-                    );
-
-                    const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
-
-                    const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-                    const transferAmount = makerBalance.sub(remainingAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        expect(orderState.isValid).to.be.true();
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingAmount,
-                        );
-                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-                            remainingAmount,
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.transferAsync(makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
-                })().catch(done);
-            });
-            it('should equal remaining amount when partially cancelled and order has fees', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        expect(orderState.isValid).to.be.true();
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingTokenAmount,
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    await zeroEx.exchange.cancelOrderAsync(signedOrder, transferTokenAmount);
-                })().catch(done);
-            });
-            it('should equal ratio amount when fee balance is lowered', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    const remainingFeeAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-
-                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            remainingFeeAmount,
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, remainingFeeAmount);
-                    await zeroEx.token.transferAsync(
-                        makerToken.address,
-                        maker,
-                        ZeroEx.NULL_ADDRESS,
-                        transferTokenAmount,
-                    );
-                })().catch(done);
-            });
-            it('should calculate full amount when all available and non-divisible', (done: DoneCallback) => {
-                (async () => {
-                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-                    const feeRecipient = taker;
-                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                        makerToken.address,
-                        takerToken.address,
-                        makerFee,
-                        takerFee,
-                        maker,
-                        taker,
-                        fillableAmount,
-                        feeRecipient,
-                    );
-
-                    zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                    const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                        const validOrderState = orderState as OrderStateValid;
-                        const orderRelevantState = validOrderState.orderRelevantState;
-                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-                            fillableAmount,
-                        );
-                    });
-                    zeroEx.orderStateWatcher.subscribe(callback);
-                    await zeroEx.token.setProxyAllowanceAsync(
-                        makerToken.address,
-                        maker,
-                        ZeroEx.toBaseUnitAmount(new BigNumber(100), decimals),
-                    );
-                })().catch(done);
-            });
-        });
-        it('should emit orderStateInvalid when watched order cancelled', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    expect(orderState.isValid).to.be.false();
-                    const invalidOrderState = orderState as OrderStateInvalid;
-                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-
-                await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-            })().catch(done);
-        });
-        it('should emit orderStateInvalid when within rounding error range', (done: DoneCallback) => {
-            (async () => {
-                const remainingFillableAmountInBaseUnits = new BigNumber(100);
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    expect(orderState.isValid).to.be.false();
-                    const invalidOrderState = orderState as OrderStateInvalid;
-                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-                await zeroEx.exchange.cancelOrderAsync(
-                    signedOrder,
-                    fillableAmount.minus(remainingFillableAmountInBaseUnits),
-                );
-            })().catch(done);
-        });
-        it('should emit orderStateValid when watched order partially cancelled', (done: DoneCallback) => {
-            (async () => {
-                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                    makerToken.address,
-                    takerToken.address,
-                    maker,
-                    taker,
-                    fillableAmount,
-                );
-
-                const cancelAmountInBaseUnits = new BigNumber(2);
-                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-                zeroEx.orderStateWatcher.addOrder(signedOrder);
-
-                const callback = reportNoErrorCallbackErrors(done)((orderState: OrderState) => {
-                    expect(orderState.isValid).to.be.true();
-                    const validOrderState = orderState as OrderStateValid;
-                    expect(validOrderState.orderHash).to.be.equal(orderHash);
-                    const orderRelevantState = validOrderState.orderRelevantState;
-                    expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
-                });
-                zeroEx.orderStateWatcher.subscribe(callback);
-                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
-            })().catch(done);
-        });
-    });
-}); // tslint:disable:max-file-line-count

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

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

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

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

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

@@ -1,85 +0,0 @@
-import { BlockchainLifecycle } 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';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { assertNodeCallbackError } from './utils/report_callback_errors';
-import { web3Factory } from './utils/web3_factory';
-
-chaiSetup.configure();
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-
-describe('SubscriptionTest', () => {
-    let web3: Web3;
-    let zeroEx: ZeroEx;
-    let userAddresses: string[];
-    let tokens: Token[];
-    let coinbase: string;
-    let addressWithoutFunds: string;
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    before(async () => {
-        web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        coinbase = userAddresses[0];
-        addressWithoutFunds = userAddresses[1];
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    describe('#subscribe', () => {
-        const indexFilterValues = {};
-        let tokenAddress: string;
-        const allowanceAmount = new BigNumber(42);
-        let stubs: Sinon.SinonStub[] = [];
-        before(() => {
-            const token = tokens[0];
-            tokenAddress = token.address;
-        });
-        afterEach(() => {
-            zeroEx.token.unsubscribeAll();
-            _.each(stubs, s => s.restore());
-            stubs = [];
-        });
-        it('Should receive the Error when an error occurs while fetching the block', (done: DoneCallback) => {
-            (async () => {
-                const errMsg = 'Error fetching block';
-                const callback = assertNodeCallbackError(done, errMsg);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error(errMsg))];
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-            })().catch(done);
-        });
-        it('Should receive the Error when an error occurs while reconciling the new block', (done: DoneCallback) => {
-            (async () => {
-                const errMsg = 'Error fetching logs';
-                const callback = assertNodeCallbackError(done, errMsg);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getLogsAsync').throws(new Error(errMsg))];
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-            })().catch(done);
-        });
-        it('Should allow unsubscribeAll to be called successfully after an error', (done: DoneCallback) => {
-            (async () => {
-                const callback = (err: Error | null, logEvent?: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error('JSON RPC error'))];
-                zeroEx.token.unsubscribeAll();
-                done();
-            })().catch(done);
-        });
-    });
-});

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

@@ -1,129 +0,0 @@
-import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { schemas, SchemaValidator } from '@0xproject/json-schemas';
-import * as chai from 'chai';
-import * as _ from 'lodash';
-import 'mocha';
-
-import { Token, ZeroEx } from '../src';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { web3Factory } from './utils/web3_factory';
-
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-
-const TOKEN_REGISTRY_SIZE_AFTER_MIGRATION = 7;
-
-describe('TokenRegistryWrapper', () => {
-    let zeroEx: ZeroEx;
-    let tokens: Token[];
-    const tokenAddressBySymbol: { [symbol: string]: string } = {};
-    const tokenAddressByName: { [symbol: string]: string } = {};
-    const tokenBySymbol: { [symbol: string]: Token } = {};
-    const tokenByName: { [symbol: string]: Token } = {};
-    const registeredSymbol = 'ZRX';
-    const registeredName = '0x Protocol Token';
-    const unregisteredSymbol = 'MAL';
-    const unregisteredName = 'Malicious Token';
-    const config = {
-        networkId: constants.TESTRPC_NETWORK_ID,
-    };
-    before(async () => {
-        const web3 = web3Factory.create();
-        zeroEx = new ZeroEx(web3.currentProvider, config);
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        _.map(tokens, token => {
-            tokenAddressBySymbol[token.symbol] = token.address;
-            tokenAddressByName[token.name] = token.address;
-            tokenBySymbol[token.symbol] = token;
-            tokenByName[token.name] = token;
-        });
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    describe('#getTokensAsync', () => {
-        it('should return all the tokens added to the tokenRegistry during the migration', async () => {
-            expect(tokens).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
-
-            const schemaValidator = new SchemaValidator();
-            _.each(tokens, token => {
-                const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
-                expect(validationResult.errors).to.have.lengthOf(0);
-            });
-        });
-    });
-    describe('#getTokenAddressesAsync', () => {
-        it('should return all the token addresses added to the tokenRegistry during the migration', async () => {
-            const tokenAddresses = await zeroEx.tokenRegistry.getTokenAddressesAsync();
-            expect(tokenAddresses).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
-
-            const schemaValidator = new SchemaValidator();
-            _.each(tokenAddresses, tokenAddress => {
-                const validationResult = schemaValidator.validate(tokenAddress, schemas.addressSchema);
-                expect(validationResult.errors).to.have.lengthOf(0);
-                expect(tokenAddress).to.not.be.equal(ZeroEx.NULL_ADDRESS);
-            });
-        });
-    });
-    describe('#getTokenAddressBySymbol', () => {
-        it('should return correct address for a token in the registry', async () => {
-            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(registeredSymbol);
-            expect(tokenAddress).to.be.equal(tokenAddressBySymbol[registeredSymbol]);
-        });
-        it('should return undefined for a token out of registry', async () => {
-            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(unregisteredSymbol);
-            expect(tokenAddress).to.be.undefined();
-        });
-    });
-    describe('#getTokenAddressByName', () => {
-        it('should return correct address for a token in the registry', async () => {
-            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(registeredName);
-            expect(tokenAddress).to.be.equal(tokenAddressByName[registeredName]);
-        });
-        it('should return undefined for a token out of registry', async () => {
-            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(unregisteredName);
-            expect(tokenAddress).to.be.undefined();
-        });
-    });
-    describe('#getTokenBySymbol', () => {
-        it('should return correct token for a token in the registry', async () => {
-            const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(registeredSymbol);
-            expect(token).to.be.deep.equal(tokenBySymbol[registeredSymbol]);
-        });
-        it('should return undefined for a token out of registry', async () => {
-            const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(unregisteredSymbol);
-            expect(token).to.be.undefined();
-        });
-    });
-    describe('#getTokenByName', () => {
-        it('should return correct token for a token in the registry', async () => {
-            const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(registeredName);
-            expect(token).to.be.deep.equal(tokenByName[registeredName]);
-        });
-        it('should return undefined for a token out of registry', async () => {
-            const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(unregisteredName);
-            expect(token).to.be.undefined();
-        });
-    });
-    describe('#getTokenIfExistsAsync', () => {
-        it('should return the token added to the tokenRegistry during the migration', async () => {
-            const aToken = tokens[0];
-
-            const token = await zeroEx.tokenRegistry.getTokenIfExistsAsync(aToken.address);
-            const schemaValidator = new SchemaValidator();
-            const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
-            expect(validationResult.errors).to.have.lengthOf(0);
-        });
-        it('should return return undefined when passed a token address not in the tokenRegistry', async () => {
-            const unregisteredTokenAddress = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-            const tokenIfExists = await zeroEx.tokenRegistry.getTokenIfExistsAsync(unregisteredTokenAddress);
-            expect(tokenIfExists).to.be.undefined();
-        });
-    });
-});

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

@@ -1,521 +0,0 @@
-import { BlockchainLifecycle } 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,
-    BlockParamLiteral,
-    BlockRange,
-    DecodedLogEvent,
-    Token,
-    TokenEvents,
-    TransferContractEventArgs,
-    ZeroEx,
-    ZeroExError,
-} from '../src';
-import { DoneCallback } from '../src/types';
-
-import { chaiSetup } from './utils/chai_setup';
-import { constants } from './utils/constants';
-import { reportNodeCallbackErrors } from './utils/report_callback_errors';
-import { TokenUtils } from './utils/token_utils';
-import { web3Factory } from './utils/web3_factory';
-
-chaiSetup.configure();
-const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
-
-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);
-        userAddresses = await zeroEx.getAvailableAddressesAsync();
-        tokens = await zeroEx.tokenRegistry.getTokensAsync();
-        tokenUtils = new TokenUtils(tokens);
-        coinbase = userAddresses[0];
-        addressWithoutFunds = userAddresses[1];
-    });
-    beforeEach(async () => {
-        await blockchainLifecycle.startAsync();
-    });
-    afterEach(async () => {
-        await blockchainLifecycle.revertAsync();
-    });
-    describe('#transferAsync', () => {
-        let token: Token;
-        let transferAmount: BigNumber;
-        before(() => {
-            token = tokens[0];
-            transferAmount = new BigNumber(42);
-        });
-        it('should successfully transfer tokens', async () => {
-            const fromAddress = coinbase;
-            const toAddress = addressWithoutFunds;
-            const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-            expect(preBalance).to.be.bignumber.equal(0);
-            await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
-            const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-            return expect(postBalance).to.be.bignumber.equal(transferAmount);
-        });
-        it('should fail to transfer tokens if fromAddress has an insufficient balance', async () => {
-            const fromAddress = addressWithoutFunds;
-            const toAddress = coinbase;
-            return expect(
-                zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
-        });
-        it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-            const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-            const fromAddress = coinbase;
-            const toAddress = coinbase;
-            return expect(
-                zeroEx.token.transferAsync(nonExistentTokenAddress, fromAddress, toAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
-        });
-    });
-    describe('#transferFromAsync', () => {
-        let token: Token;
-        let toAddress: string;
-        let senderAddress: string;
-        before(async () => {
-            token = tokens[0];
-            toAddress = addressWithoutFunds;
-            senderAddress = userAddresses[2];
-        });
-        it('should fail to transfer tokens if fromAddress has insufficient allowance set', async () => {
-            const fromAddress = coinbase;
-            const transferAmount = new BigNumber(42);
-
-            const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
-            expect(fromAddressBalance).to.be.bignumber.greaterThan(transferAmount);
-
-            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress, toAddress);
-            expect(fromAddressAllowance).to.be.bignumber.equal(0);
-
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
-        });
-        it('[regression] should fail to transfer tokens if set allowance for toAddress instead of senderAddress', async () => {
-            const fromAddress = coinbase;
-            const transferAmount = new BigNumber(42);
-
-            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, toAddress, transferAmount);
-
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
-        });
-        it('should fail to transfer tokens if fromAddress has insufficient balance', async () => {
-            const fromAddress = addressWithoutFunds;
-            const transferAmount = new BigNumber(42);
-
-            const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
-            expect(fromAddressBalance).to.be.bignumber.equal(0);
-
-            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
-            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(
-                token.address,
-                fromAddress,
-                senderAddress,
-            );
-            expect(fromAddressAllowance).to.be.bignumber.equal(transferAmount);
-
-            return expect(
-                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
-        });
-        it('should successfully transfer tokens', async () => {
-            const fromAddress = coinbase;
-
-            const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-            expect(preBalance).to.be.bignumber.equal(0);
-
-            const transferAmount = new BigNumber(42);
-            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
-
-            await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount);
-            const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-            return expect(postBalance).to.be.bignumber.equal(transferAmount);
-        });
-        it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-            const fromAddress = coinbase;
-            const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-            return expect(
-                zeroEx.token.transferFromAsync(
-                    nonExistentTokenAddress,
-                    fromAddress,
-                    toAddress,
-                    senderAddress,
-                    new BigNumber(42),
-                ),
-            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
-        });
-    });
-    describe('#getBalanceAsync', () => {
-        describe('With web3 provider with accounts', () => {
-            it('should return the balance for an existing ERC20 token', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const balance = await zeroEx.token.getBalanceAsync(token.address, ownerAddress);
-                const expectedBalance = new BigNumber('1000000000000000000000000000');
-                return expect(balance).to.be.bignumber.equal(expectedBalance);
-            });
-            it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-                const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-                const ownerAddress = coinbase;
-                return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress)).to.be.rejectedWith(
-                    ZeroExError.TokenContractDoesNotExist,
-                );
-            });
-            it('should return a balance of 0 for a non-existent owner address', async () => {
-                const token = tokens[0];
-                const nonExistentOwner = '0x198c6ad858f213fb31b6fe809e25040e6b964593';
-                const balance = await zeroEx.token.getBalanceAsync(token.address, nonExistentOwner);
-                const expectedBalance = new BigNumber(0);
-                return expect(balance).to.be.bignumber.equal(expectedBalance);
-            });
-        });
-        describe('With web3 provider without accounts', () => {
-            let zeroExWithoutAccounts: ZeroEx;
-            before(async () => {
-                const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create(hasAddresses);
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
-            });
-            it('should return balance even when called with Web3 provider instance without addresses', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
-                const expectedBalance = new BigNumber('1000000000000000000000000000');
-                return expect(balance).to.be.bignumber.equal(expectedBalance);
-            });
-        });
-    });
-    describe('#setAllowanceAsync', () => {
-        it("should set the spender's allowance", async () => {
-            const token = tokens[0];
-            const ownerAddress = coinbase;
-            const spenderAddress = addressWithoutFunds;
-
-            const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(
-                token.address,
-                ownerAddress,
-                spenderAddress,
-            );
-            const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
-            expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
-
-            const amountInBaseUnits = new BigNumber(50);
-            await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-            const allowanceAfterSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-            const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
-            return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
-        });
-    });
-    describe('#setUnlimitedAllowanceAsync', () => {
-        it("should set the unlimited spender's allowance", async () => {
-            const token = tokens[0];
-            const ownerAddress = coinbase;
-            const spenderAddress = addressWithoutFunds;
-
-            await zeroEx.token.setUnlimitedAllowanceAsync(token.address, ownerAddress, spenderAddress);
-            const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-            return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-        });
-        it('should reduce the gas cost for transfers including tokens with unlimited allowance support', async () => {
-            const transferAmount = new BigNumber(5);
-            const zrx = tokenUtils.getProtocolTokenOrThrow();
-            const [, userWithNormalAllowance, userWithUnlimitedAllowance] = userAddresses;
-            await zeroEx.token.setAllowanceAsync(zrx.address, coinbase, userWithNormalAllowance, transferAmount);
-            await zeroEx.token.setUnlimitedAllowanceAsync(zrx.address, coinbase, userWithUnlimitedAllowance);
-
-            const initBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-            const initBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-                userWithUnlimitedAllowance,
-            );
-
-            await zeroEx.token.transferFromAsync(
-                zrx.address,
-                coinbase,
-                userWithNormalAllowance,
-                userWithNormalAllowance,
-                transferAmount,
-            );
-            await zeroEx.token.transferFromAsync(
-                zrx.address,
-                coinbase,
-                userWithUnlimitedAllowance,
-                userWithUnlimitedAllowance,
-                transferAmount,
-            );
-
-            const finalBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-            const finalBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-                userWithUnlimitedAllowance,
-            );
-
-            const normalGasCost = initBalanceWithNormalAllowance.minus(finalBalanceWithNormalAllowance);
-            const unlimitedGasCost = initBalanceWithUnlimitedAllowance.minus(finalBalanceWithUnlimitedAllowance);
-
-            // In theory the gas cost with unlimited allowance should be smaller, but with testrpc it's actually bigger.
-            // This needs to be investigated in ethereumjs-vm. This test is essentially a repro.
-            // TODO: Make this test pass with inverted assertion.
-            expect(unlimitedGasCost.toNumber()).to.be.gt(normalGasCost.toNumber());
-        });
-    });
-    describe('#getAllowanceAsync', () => {
-        describe('With web3 provider with accounts', () => {
-            it('should get the proxy allowance', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const spenderAddress = addressWithoutFunds;
-
-                const amountInBaseUnits = new BigNumber(50);
-                await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-                const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-                const expectedAllowance = amountInBaseUnits;
-                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-            });
-            it('should return 0 if no allowance set yet', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const spenderAddress = addressWithoutFunds;
-                const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-                const expectedAllowance = new BigNumber(0);
-                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-            });
-        });
-        describe('With web3 provider without accounts', () => {
-            let zeroExWithoutAccounts: ZeroEx;
-            before(async () => {
-                const hasAddresses = false;
-                const web3WithoutAccounts = web3Factory.create(hasAddresses);
-                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
-            });
-            it('should get the proxy allowance', async () => {
-                const token = tokens[0];
-                const ownerAddress = coinbase;
-                const spenderAddress = addressWithoutFunds;
-
-                const amountInBaseUnits = new BigNumber(50);
-                await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-                const allowance = await zeroExWithoutAccounts.token.getAllowanceAsync(
-                    token.address,
-                    ownerAddress,
-                    spenderAddress,
-                );
-                const expectedAllowance = amountInBaseUnits;
-                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-            });
-        });
-    });
-    describe('#getProxyAllowanceAsync', () => {
-        it('should get the proxy allowance', async () => {
-            const token = tokens[0];
-            const ownerAddress = coinbase;
-
-            const amountInBaseUnits = new BigNumber(50);
-            await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
-
-            const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-            const expectedAllowance = amountInBaseUnits;
-            return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-        });
-    });
-    describe('#setProxyAllowanceAsync', () => {
-        it('should set the proxy allowance', async () => {
-            const token = tokens[0];
-            const ownerAddress = coinbase;
-
-            const allowanceBeforeSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-            const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
-            expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
-
-            const amountInBaseUnits = new BigNumber(50);
-            await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
-
-            const allowanceAfterSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-            const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
-            return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
-        });
-    });
-    describe('#setUnlimitedProxyAllowanceAsync', () => {
-        it('should set the unlimited proxy allowance', async () => {
-            const token = tokens[0];
-            const ownerAddress = coinbase;
-
-            await zeroEx.token.setUnlimitedProxyAllowanceAsync(token.address, ownerAddress);
-            const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-            return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-        });
-    });
-    describe('#subscribe', () => {
-        const indexFilterValues = {};
-        let tokenAddress: string;
-        const transferAmount = new BigNumber(42);
-        const allowanceAmount = new BigNumber(42);
-        before(() => {
-            const token = tokens[0];
-            tokenAddress = token.address;
-        });
-        afterEach(() => {
-            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,
-        // we do need both. A hack is to make the top-level a sync fn w/ a done callback and then
-        // wrap the rest of the test in an async block
-        // Source: https://github.com/mochajs/mocha/issues/2407
-        it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
-            (async () => {
-                const callback = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
-                        expect(logEvent.isRemoved).to.be.false();
-                        expect(logEvent.log.logIndex).to.be.equal(0);
-                        expect(logEvent.log.transactionIndex).to.be.equal(0);
-                        expect(logEvent.log.blockNumber).to.be.a('number');
-                        const args = logEvent.log.args;
-                        expect(args._from).to.be.equal(coinbase);
-                        expect(args._to).to.be.equal(addressWithoutFunds);
-                        expect(args._value).to.be.bignumber.equal(transferAmount);
-                    },
-                );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callback);
-                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-            })().catch(done);
-        });
-        it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
-            (async () => {
-                const callback = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        expect(logEvent).to.not.be.undefined();
-                        expect(logEvent.isRemoved).to.be.false();
-                        const args = logEvent.log.args;
-                        expect(args._owner).to.be.equal(coinbase);
-                        expect(args._spender).to.be.equal(addressWithoutFunds);
-                        expect(args._value).to.be.bignumber.equal(allowanceAmount);
-                    },
-                );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-            })().catch(done);
-        });
-        it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
-            (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        done(new Error('Expected this subscription to have been cancelled'));
-                    },
-                );
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
-                const callbackToBeCalled = reportNodeCallbackErrors(done)();
-                const newProvider = web3Factory.getRpcProvider();
-                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
-                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled);
-                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-            })().catch(done);
-        });
-        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
-            (async () => {
-                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-                        done(new Error('Expected this subscription to have been cancelled'));
-                    },
-                );
-                const subscriptionToken = zeroEx.token.subscribe(
-                    tokenAddress,
-                    TokenEvents.Transfer,
-                    indexFilterValues,
-                    callbackNeverToBeCalled,
-                );
-                zeroEx.token.unsubscribe(subscriptionToken);
-                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-                done();
-            })().catch(done);
-        });
-    });
-    describe('#getLogsAsync', () => {
-        let tokenAddress: string;
-        let tokenTransferProxyAddress: string;
-        const blockRange: BlockRange = {
-            fromBlock: 0,
-            toBlock: BlockParamLiteral.Latest,
-        };
-        let txHash: string;
-        before(() => {
-            const token = tokens[0];
-            tokenAddress = token.address;
-            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
-        });
-        it('should get logs with decoded args emitted by Approval', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            const eventName = TokenEvents.Approval;
-            const indexFilterValues = {};
-            const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-                tokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(1);
-            const args = logs[0].args;
-            expect(logs[0].event).to.be.equal(eventName);
-            expect(args._owner).to.be.equal(coinbase);
-            expect(args._spender).to.be.equal(tokenTransferProxyAddress);
-            expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-        });
-        it('should only get the logs with the correct event name', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            const differentEventName = TokenEvents.Transfer;
-            const indexFilterValues = {};
-            const logs = await zeroEx.token.getLogsAsync(
-                tokenAddress,
-                differentEventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(0);
-        });
-        it('should only get the logs with the correct indexed fields', async () => {
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, addressWithoutFunds);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
-            const eventName = TokenEvents.Approval;
-            const indexFilterValues = {
-                _owner: coinbase,
-            };
-            const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-                tokenAddress,
-                eventName,
-                blockRange,
-                indexFilterValues,
-            );
-            expect(logs).to.have.length(1);
-            const args = logs[0].args;
-            expect(args._owner).to.be.equal(coinbase);
-        });
-    });
-});
-// tslint:disable:max-file-line-count

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

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

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

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

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

@@ -1,44 +0,0 @@
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
-
-import { SignedOrder, ZeroEx } from '../../src';
-
-export const orderFactory = {
-    async createSignedOrderAsync(
-        zeroEx: ZeroEx,
-        maker: string,
-        taker: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerTokenAmount: BigNumber,
-        makerTokenAddress: string,
-        takerTokenAmount: BigNumber,
-        takerTokenAddress: string,
-        exchangeContractAddress: string,
-        feeRecipient: string,
-        expirationUnixTimestampSecIfExists?: BigNumber,
-    ): Promise<SignedOrder> {
-        const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
-        const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
-            ? defaultExpirationUnixTimestampSec
-            : expirationUnixTimestampSecIfExists;
-        const order = {
-            maker,
-            taker,
-            makerFee,
-            takerFee,
-            makerTokenAmount,
-            takerTokenAmount,
-            makerTokenAddress,
-            takerTokenAddress,
-            salt: ZeroEx.generatePseudoRandomSalt(),
-            exchangeContractAddress,
-            feeRecipient,
-            expirationUnixTimestampSec,
-        };
-        const orderHash = ZeroEx.getOrderHashHex(order);
-        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker);
-        const signedOrder: SignedOrder = _.assign(order, { ecSignature });
-        return signedOrder;
-    },
-};

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

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

packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts

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

packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts

@@ -1,34 +0,0 @@
-import { JSONRPCPayload } from '../../../src/types';
-
-/*
- * This class implements the web3-provider-engine subprovider interface and returns
- * the constant gas estimate when queried.
- * HACK: We need this so that our tests don't use testrpc gas estimation which sometimes kills the node.
- * Source: https://github.com/trufflesuite/ganache-cli/issues/417
- * Source: https://github.com/trufflesuite/ganache-cli/issues/437
- * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
- */
-export class FakeGasEstimateSubprovider {
-    private _constantGasAmount: number;
-    constructor(constantGasAmount: number) {
-        this._constantGasAmount = constantGasAmount;
-    }
-    // This method needs to be here to satisfy the interface but linter wants it to be static.
-    // tslint:disable-next-line:prefer-function-over-method
-    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
-        switch (payload.method) {
-            case 'eth_estimateGas':
-                end(null, this._constantGasAmount);
-                return;
-
-            default:
-                next();
-                return;
-        }
-    }
-    // Required to implement this method despite not needing it for this subprovider
-    // tslint:disable-next-line:prefer-function-over-method
-    public setEngine(engine: any) {
-        // noop
-    }
-}

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

@@ -1,42 +0,0 @@
-// HACK: web3 injects XMLHttpRequest into the global scope and ProviderEngine checks XMLHttpRequest
-// to know whether it is running in a browser or node environment. We need it to be undefined since
-// we are not running in a browser env.
-// Filed issue: https://github.com/ethereum/web3.js/issues/844
-(global as any).XMLHttpRequest = undefined;
-import ProviderEngine = require('web3-provider-engine');
-import RpcSubprovider = require('web3-provider-engine/subproviders/rpc');
-
-import { EmptyWalletSubprovider } from './subproviders/empty_wallet_subprovider';
-import { FakeGasEstimateSubprovider } from './subproviders/fake_gas_estimate_subprovider';
-
-import { constants } from './constants';
-
-// HACK: web3 leaks XMLHttpRequest into the global scope and causes requests to hang
-// because they are using the wrong XHR package.
-// importing web3 after subproviders fixes this issue
-// Filed issue: https://github.com/ethereum/web3.js/issues/844
-// tslint:disable-next-line:ordered-imports
-import * as Web3 from 'web3';
-
-export const web3Factory = {
-    create(hasAddresses: boolean = true): Web3 {
-        const provider = this.getRpcProvider(hasAddresses);
-        const web3 = new Web3();
-        web3.setProvider(provider);
-        return web3;
-    },
-    getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
-        const provider = new ProviderEngine();
-        if (!hasAddresses) {
-            provider.addProvider(new EmptyWalletSubprovider());
-        }
-        provider.addProvider(new FakeGasEstimateSubprovider(constants.GAS_ESTIMATE));
-        provider.addProvider(
-            new RpcSubprovider({
-                rpcUrl: constants.RPC_URL,
-            }),
-        );
-        provider.start();
-        return provider;
-    },
-};

packages/0x.js/tsconfig.json

@@ -2,15 +2,7 @@
     "extends": "../../tsconfig",
     "compilerOptions": {
         "outDir": "lib",
-        "noImplicitThis": false
+        "rootDir": "src"
     },
-    "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/**/*"]
 }

packages/0x.js/typedoc-tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../typedoc-tsconfig",
+    "compilerOptions": {
+        "outDir": "lib"
+    },
+    "include": ["./src/**/*", "./test/**/*"]
+}

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

@@ -3,14 +3,15 @@
  */
 const _ = require('lodash');
 const webpack = require('webpack');
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
 const path = require('path');
 const production = process.env.NODE_ENV === 'production';
 
 let entry = {
-    'index': './src/index.ts',
+    index: './src/index.ts',
 };
 if (production) {
-    entry = _.assign({}, entry, {'index.min': './src/index.ts'});
+    entry = _.assign({}, entry, { 'index.min': './src/index.ts' });
 }
 
 module.exports = {
@@ -27,10 +28,16 @@ module.exports = {
     },
     devtool: 'source-map',
     plugins: [
-        new webpack.optimize.UglifyJsPlugin({
-            minimize: true,
+        // TODO: Revert to webpack bundled version with webpack v4.
+        // The v3 series bundled version does not support ES6 and
+        // fails to build.
+        new UglifyJsPlugin({
             sourceMap: true,
-            include: /\.min\.js$/,
+            uglifyOptions: {
+                mangle: {
+                    reserved: ['BigNumber'],
+                },
+            },
         }),
     ],
     module: {
@@ -40,8 +47,13 @@ module.exports = {
                 use: [
                     {
                         loader: 'awesome-typescript-loader',
+                        // tsconfig.json contains some options required for
+                        // project references which do not work with webback.
+                        // We override those options here.
                         query: {
                             declaration: false,
+                            declarationMap: false,
+                            composite: false,
                         },
                     },
                 ],

packages/abi-gen/.npmignore

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

packages/abi-gen/CHANGELOG.json

@@ -0,0 +1,275 @@
+[
+    {
+        "timestamp": 1537541580,
+        "version": "1.0.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1536142250,
+        "version": "1.0.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1535377027,
+        "version": "1.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1535133899,
+        "version": "1.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1534210131,
+        "version": "1.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532619515,
+        "version": "1.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532614997,
+        "version": "1.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532605697,
+        "version": "1.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Fix the abi-gen entry point in package.json",
+                "pr": 901
+            }
+        ],
+        "timestamp": 1532357734
+    },
+    {
+        "timestamp": 1532043000,
+        "version": "1.0.0",
+        "changes": [
+            {
+                "note": "Convert e_r_c to erc in generated file names",
+                "pr": 822
+            },
+            {
+                "note": "Remove the output directory before writing to it",
+                "pr": 822
+            },
+            {
+                "note": "skip generation of wrappers that are already up to date",
+                "pr": 788
+            }
+        ]
+    },
+    {
+        "timestamp": 1531919263,
+        "version": "0.3.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1531149657,
+        "version": "0.3.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1529397769,
+        "version": "0.3.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.3.1",
+        "changes": [
+            {
+                "note": "Incorrect publish that was unpublished"
+            }
+        ],
+        "timestamp": 1527810075
+    },
+    {
+        "version": "0.3.0",
+        "changes": [
+            {
+                "note": "Properly export the executable binary",
+                "pr": 588
+            }
+        ],
+        "timestamp": 1527008270
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.2.13",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525428773,
+        "version": "0.2.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1524044013,
+        "version": "0.2.11",
+        "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,7 +1,117 @@
-# CHANGELOG
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
 
-## v0.1.0 - _January 11, 2018_
+CHANGELOG
 
-* Fixed array typings with union types (#295)
-* Add event ABIs to context data passed to templates (#302)
-* Add constructor ABIs to context data passed to templates (#304)
+## v1.0.9 - _September 21, 2018_
+
+    * Dependencies updated
+
+## v1.0.8 - _September 5, 2018_
+
+    * Dependencies updated
+
+## v1.0.7 - _August 27, 2018_
+
+    * Dependencies updated
+
+## v1.0.6 - _August 24, 2018_
+
+    * Dependencies updated
+
+## v1.0.5 - _August 14, 2018_
+
+    * Dependencies updated
+
+## v1.0.4 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.3 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.2 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.1 - _July 23, 2018_
+
+    * Fix the abi-gen entry point in package.json (#901)
+
+## v1.0.0 - _July 20, 2018_
+
+    * Convert e_r_c to erc in generated file names (#822)
+    * Remove the output directory before writing to it (#822)
+    * skip generation of wrappers that are already up to date (#788)
+
+## v0.3.4 - _July 18, 2018_
+
+    * Dependencies updated
+
+## v0.3.3 - _July 9, 2018_
+
+    * Dependencies updated
+
+## v0.3.2 - _June 19, 2018_
+
+    * Dependencies updated
+
+## v0.3.1 - _June 1, 2018_
+
+    * Incorrect publish that was unpublished
+
+## v0.3.0 - _May 22, 2018_
+
+    * Properly export the executable binary (#588)
+
+## v0.2.13 - _May 5, 2018_
+
+    * Dependencies updated
+
+## v0.2.12 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.2.11 - _April 18, 2018_
+
+    * Dependencies updated
+
+## v0.2.10 - _April 11, 2018_
+
+    * Dependencies updated
+
+## v0.2.9 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.8 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.5 - _March 17, 2018_
+
+    * Consolidate all `console.log` calls into `logUtils` in the `@0xproject/utils` package (#452)
+
+## v0.2.4 - _March 3, 2018_
+
+    * Add a `backend` parameter that allows you to specify the Ethereum library you use in your templates (`web3` or `ethers`). Ethers auto-converts small ints to numbers whereas Web3 doesn't. Defaults to `web3` (#413)
+    * Add support for [tuple types](https://solidity.readthedocs.io/en/develop/abi-spec.html#handling-tuple-types) (#413)
+    * Add `hasReturnValue` to context data (#413)
+
+## v0.2.1 - _February 8, 2018_
+
+    * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
+
+## v0.2.0 - _February 6, 2018_
+
+    * Added CLI options for explicit specifying location of partials and main template (#346)
+    * Added CLI option to specify networkId, adding support for the JSON artifact format found in @0xproject/contracts (#388)
+
+## v0.1.0 - _January 10, 2018_
+
+    * Fixed array typings with union types (#295)
+    * Add event ABIs to context data passed to templates (#302)
+    * Add constructor ABIs to context data passed to templates (#304)

packages/abi-gen/README.md

@@ -4,8 +4,7 @@ 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.
+[Here](https://github.com/0xProject/0x-monorepo/tree/development/packages/0x.js/contract_templates) are the templates used to generate the contract wrappers used by 0x.js.e
 
 ## Installation
 
@@ -16,35 +15,90 @@ 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/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
+
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
+```bash
+PKG=@0xproject/abi-gen yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=@0xproject/abi-gen yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
+```
+
+### Lint
+
+```bash
+yarn lint
+```

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

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

packages/abi-gen/package.json

@@ -1,48 +1,68 @@
 {
     "name": "@0xproject/abi-gen",
-    "version": "0.1.1",
+    "version": "1.0.9",
+    "engines": {
+        "node": ">=6.12"
+    },
     "description": "Generate contract wrappers from ABI and handlebars templates",
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
     "scripts": {
-        "lint": "tslint --project . 'src/**/*.ts'",
+        "lint": "tslint --project .",
         "clean": "shx rm -rf lib",
-        "build": "tsc"
+        "build": "tsc -b",
+        "test": "yarn run_mocha",
+        "run_mocha": "mocha --require source-map-support/register --require make-promises-safe lib/test/**/*_test.js --bail --exit",
+        "test:circleci": "yarn test:coverage",
+        "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
+        "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info"
     },
     "bin": {
-        "abi-gen": "lib/index.js"
+        "abi-gen": "bin/abi-gen.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.1.3",
+        "@0xproject/typescript-typings": "^2.0.1",
+        "@0xproject/utils": "^1.0.9",
         "chalk": "^2.3.0",
+        "ethereum-types": "^1.0.7",
         "glob": "^7.1.2",
         "handlebars": "^4.0.11",
-        "lodash": "^4.17.4",
+        "lodash": "^4.17.5",
         "mkdirp": "^0.5.1",
+        "sleep": "^5.1.1",
+        "tmp": "^0.0.33",
         "to-snake-case": "^1.0.0",
-        "web3": "^0.20.0",
         "yargs": "^10.0.3"
     },
     "devDependencies": {
-        "@0xproject/tslint-config": "^0.4.1",
-        "@types/glob": "^5.0.33",
+        "@0xproject/tslint-config": "^1.0.7",
+        "@types/glob": "5.0.35",
         "@types/handlebars": "^4.0.36",
         "@types/mkdirp": "^0.5.1",
-        "@types/node": "^8.0.53",
+        "@types/node": "*",
+        "@types/sleep": "^0.0.7",
+        "@types/tmp": "^0.0.33",
         "@types/yargs": "^10.0.0",
+        "chai": "^4.1.2",
+        "copyfiles": "^2.0.0",
+        "dirty-chai": "^2.0.1",
+        "make-promises-safe": "^1.1.0",
+        "mocha": "^5.2.0",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
-        "tslint": "5.8.0",
-        "typescript": "~2.6.1",
-        "web3-typescript-typings": "^0.9.3"
+        "tslint": "5.11.0",
+        "typescript": "3.0.1"
+    },
+    "publishConfig": {
+        "access": "public"
     }
 }

packages/abi-gen/scripts/postpublish.js

@@ -1,14 +0,0 @@
-const postpublish_utils = require('../../../scripts/postpublish_utils');
-const packageJSON = require('../package.json');
-
-const subPackageName = packageJSON.name;
-
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
-    .then(function(result) {
-        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
-        const assets = [];
-        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
-    })
-    .catch (function(err) {
-        throw err;
-    });

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,103 +1,144 @@
 #!/usr/bin/env node
 
+import { abiUtils, logUtils } from '@0xproject/utils';
 import chalk from 'chalk';
-import * as fs from 'fs';
+import { AbiDefinition, ConstructorAbi, EventAbi, MethodAbi } from 'ethereum-types';
 import { sync as globSync } from 'glob';
 import * as Handlebars from 'handlebars';
 import * as _ from 'lodash';
 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, ParamKind } from './types';
 import { utils } from './utils';
 
 const ABI_TYPE_CONSTRUCTOR = 'constructor';
 const ABI_TYPE_METHOD = 'function';
 const ABI_TYPE_EVENT = 'event';
-const MAIN_TEMPLATE_NAME = 'contract.mustache';
+const DEFAULT_NETWORK_ID = 50;
+const DEFAULT_BACKEND = 'web3';
 
 const args = yargs
-    .option('abiGlob', {
+    .option('abis', {
         describe: 'Glob pattern to search for ABI JSON files',
         type: 'string',
-        demand: true,
-    })
-    .option('templates', {
-        describe: 'Folder where to search for templates',
-        type: 'string',
-        demand: true,
+        demandOption: true,
     })
     .option('output', {
+        alias: ['o', 'out'],
         describe: 'Folder where to put the output files',
         type: 'string',
-        demand: true,
-    }).argv;
+        normalize: true,
+        demandOption: true,
+    })
+    .option('partials', {
+        describe: 'Glob pattern for the partial template files',
+        type: 'string',
+        implies: 'template',
+    })
+    .option('template', {
+        describe: 'Path for the main template file that will be used to generate each contract',
+        type: 'string',
+        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',
+        default: DEFAULT_NETWORK_ID,
+    })
+    .example(
+        "$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'",
+        'Full usage example',
+    ).argv;
 
-function writeOutputFile(name: string, renderedTsCode: string): void {
-    const fileName = toSnakeCase(name);
-    const filePath = `${args.output}/${fileName}.ts`;
-    fs.writeFileSync(filePath, renderedTsCode);
-    utils.log(`Created: ${chalk.bold(filePath)}`);
+function registerPartials(partialsGlob: string): void {
+    const partialTemplateFileNames = globSync(partialsGlob);
+    logUtils.log(`Found ${chalk.green(`${partialTemplateFileNames.length}`)} ${chalk.bold('partial')} templates`);
+    for (const partialTemplateFileName of partialTemplateFileNames) {
+        const namedContent = utils.getNamedContent(partialTemplateFileName);
+        Handlebars.registerPartial(namedContent.name, namedContent.content);
+    }
 }
 
-Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input));
-Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output));
-const partialTemplateFileNames = globSync(`${args.templates}/partials/**/*.mustache`);
-for (const partialTemplateFileName of partialTemplateFileNames) {
-    const namedContent = utils.getNamedContent(partialTemplateFileName);
-    Handlebars.registerPartial(namedContent.name, namedContent.content);
+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);
 }
-
-const mainTemplate = utils.getNamedContent(`${args.templates}/${MAIN_TEMPLATE_NAME}`);
+const mainTemplate = utils.getNamedContent(args.template);
 const template = Handlebars.compile<ContextData>(mainTemplate.content);
-const abiFileNames = globSync(args.abiGlob);
+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);
-    const ABI = _.isArray(parsedContent)
-        ? parsedContent // ABI file
-        : parsedContent.abi; // Truffle contracts file
+    let ABI;
+    if (_.isArray(parsedContent)) {
+        ABI = parsedContent; // ABI file
+    } else if (!_.isUndefined(parsedContent.abi)) {
+        ABI = parsedContent.abi; // Truffle artifact
+    } else if (!_.isUndefined(parsedContent.compilerOutput.abi)) {
+        ABI = parsedContent.compilerOutput.abi; // 0x artifact
+    }
     if (_.isUndefined(ABI)) {
-        utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`);
-        utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`);
+        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 sol-compiler artifact`,
+        );
         process.exit(1);
     }
 
-    let ctor = ABI.find((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_CONSTRUCTOR) as Web3.ConstructorAbi;
+    const outFileName = utils.makeOutputFileName(namedContent.name);
+    const outFilePath = `${args.output}/${outFileName}.ts`;
+
+    if (utils.isOutputFileUpToDate(abiFileName, outFilePath)) {
+        logUtils.log(`Already up to date: ${chalk.bold(outFilePath)}`);
+        continue;
+    }
+
+    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 => {
+    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';
+                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,
@@ -106,5 +147,6 @@ for (const abiFileName of abiFileNames) {
         events: eventAbis,
     };
     const renderedTsCode = template(contextData);
-    writeOutputFile(namedContent.name, renderedTsCode);
+    utils.writeOutputFile(outFilePath, renderedTsCode);
+    logUtils.log(`Created: ${chalk.bold(outFilePath)}`);
 }

packages/abi-gen/src/types.ts

@@ -1,23 +1,24 @@
-import * as Web3 from 'web3';
+import { EventAbi, MethodAbi } from 'ethereum-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,21 @@
+import { AbiType, ConstructorAbi, DataItem } from 'ethereum-types';
 import * as fs from 'fs';
 import * as _ from 'lodash';
 import * as path from 'path';
-import * as Web3 from 'web3';
+import toSnakeCase = require('to-snake-case');
 
-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 +26,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.join(';')}}`;
+                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 +85,7 @@ export const utils = {
             throw new Error(`Failed to read ${filename}: ${err}`);
         }
     },
-    getEmptyConstructor(): Web3.ConstructorAbi {
+    getEmptyConstructor(): ConstructorAbi {
         return {
             type: AbiType.Constructor,
             stateMutability: 'nonpayable',
@@ -70,4 +93,27 @@ export const utils = {
             inputs: [],
         };
     },
+    makeOutputFileName(name: string): string {
+        let fileName = toSnakeCase(name);
+        // HACK: Snake case doesn't make a lot of sense for abbreviated names but we can't reliably detect abbreviations
+        // so we special-case the abbreviations we use.
+        fileName = fileName.replace('z_r_x', 'zrx').replace('e_r_c', 'erc');
+        return fileName;
+    },
+    writeOutputFile(filePath: string, renderedTsCode: string): void {
+        fs.writeFileSync(filePath, renderedTsCode);
+    },
+    isOutputFileUpToDate(abiFile: string, outputFile: string): boolean {
+        const abiFileModTimeMs = fs.statSync(abiFile).mtimeMs;
+        try {
+            const outFileModTimeMs = fs.statSync(outputFile).mtimeMs;
+            return outFileModTimeMs > abiFileModTimeMs;
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                return false;
+            } else {
+                throw err;
+            }
+        }
+    },
 };

packages/abi-gen/test/utils_test.ts

@@ -0,0 +1,86 @@
+import * as chai from 'chai';
+import * as dirtyChai from 'dirty-chai';
+import * as fs from 'fs';
+import 'mocha';
+import * as tmp from 'tmp';
+
+import { utils } from '../src/utils';
+
+tmp.setGracefulCleanup(); // remove tmp files even if there are failures
+
+chai.use(dirtyChai);
+
+const expect = chai.expect;
+
+describe('makeOutputFileName()', () => {
+    it('should handle Metacoin usage', () => {
+        expect(utils.makeOutputFileName('Metacoin')).to.equal('metacoin');
+    });
+    it('should handle special zrx_token case', () => {
+        expect(utils.makeOutputFileName('ZRXToken')).to.equal('zrx_token');
+    });
+    it('should handle special erc_token case', () => {
+        expect(utils.makeOutputFileName('ERC20Token')).to.equal('erc20_token');
+    });
+});
+
+describe('writeOutputFile()', () => {
+    let tempFilePath: string;
+    before(() => {
+        tempFilePath = tmp.fileSync(
+            { discardDescriptor: true }, // close file (so we can update it)
+        ).name;
+    });
+    it('should write content to output file', () => {
+        const content = 'hello world';
+
+        utils.writeOutputFile(tempFilePath, content);
+
+        expect(fs.readFileSync(tempFilePath).toString()).to.equal(content);
+    });
+});
+
+describe('isOutputFileUpToDate()', () => {
+    it('should throw ENOENT when there is no abi file', () => {
+        expect(utils.isOutputFileUpToDate.bind('nonexistant1', 'nonexistant2')).to.throw('ENOENT');
+    });
+
+    describe('when the abi input file exists', () => {
+        let abiFile: string;
+        before(() => {
+            abiFile = tmp.fileSync(
+                { discardDescriptor: true }, // close file (set timestamp)
+            ).name;
+        });
+
+        describe('without an existing output file', () => {
+            it('should return false', () => {
+                expect(utils.isOutputFileUpToDate(abiFile, 'nonexistant_file')).to.be.false();
+            });
+        });
+
+        describe('with an existing output file', () => {
+            let outputFile: string;
+            before(() => {
+                outputFile = tmp.fileSync(
+                    { discardDescriptor: true }, // close file (set timestamp)
+                ).name;
+                const abiFileModTimeMs = fs.statSync(abiFile).mtimeMs;
+                const outfileModTimeMs = abiFileModTimeMs + 1;
+                fs.utimesSync(outputFile, outfileModTimeMs, outfileModTimeMs);
+            });
+
+            it('should return true when output file is newer than abi file', async () => {
+                expect(utils.isOutputFileUpToDate(abiFile, outputFile)).to.be.true();
+            });
+
+            it('should return false when output file exists but is older than abi file', () => {
+                const outFileModTimeMs = fs.statSync(outputFile).mtimeMs;
+                const abiFileModTimeMs = outFileModTimeMs + 1;
+                fs.utimesSync(abiFile, abiFileModTimeMs, abiFileModTimeMs);
+
+                expect(utils.isOutputFileUpToDate(abiFile, outputFile)).to.be.false();
+            });
+        });
+    });
+});

packages/abi-gen/tsconfig.json

@@ -1,7 +1,8 @@
 {
     "extends": "../../tsconfig",
     "compilerOptions": {
-        "outDir": "lib"
+        "outDir": "lib",
+        "rootDir": "."
     },
-    "include": ["./src/**/*", "./test/**/*", "../../node_modules/web3-typescript-typings/index.d.ts"]
+    "include": ["./src/**/*", "./test/**/*"]
 }

packages/assert/.npmignore

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

packages/assert/CHANGELOG.json

@@ -0,0 +1,240 @@
+[
+    {
+        "timestamp": 1537541580,
+        "version": "1.0.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1536142250,
+        "version": "1.0.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1535377027,
+        "version": "1.0.7",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1535133899,
+        "version": "1.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1534210131,
+        "version": "1.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532619515,
+        "version": "1.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532614997,
+        "version": "1.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532605697,
+        "version": "1.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532357734,
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1532043000,
+        "version": "1.0.0",
+        "changes": [
+            {
+                "note":
+                    "Fix bug in string enum assertion. We erroneously were checking against the enum keys, not values",
+                "pr": 821
+            }
+        ]
+    },
+    {
+        "timestamp": 1531919263,
+        "version": "0.2.14",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1531149657,
+        "version": "0.2.13",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1529397769,
+        "version": "0.2.12",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "0.2.11",
+        "changes": [
+            {
+                "note": "Incorrect publish that was unpublished"
+            }
+        ],
+        "timestamp": 1527810075
+    },
+    {
+        "timestamp": 1527008270,
+        "version": "0.2.10",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525477860,
+        "version": "0.2.9",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1525428773,
+        "version": "0.2.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1524044013,
+        "version": "0.2.7",
+        "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,6 +1,108 @@
-# CHANGELOG
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
 
-## v0.0.4 - _Nov. 14, 2017_
+CHANGELOG
+
+## v1.0.9 - _September 21, 2018_
+
+    * Dependencies updated
+
+## v1.0.8 - _September 5, 2018_
+
+    * Dependencies updated
+
+## v1.0.7 - _August 27, 2018_
+
+    * Dependencies updated
+
+## v1.0.6 - _August 24, 2018_
+
+    * Dependencies updated
+
+## v1.0.5 - _August 14, 2018_
+
+    * Dependencies updated
+
+## v1.0.4 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.3 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.2 - _July 26, 2018_
+
+    * Dependencies updated
+
+## v1.0.1 - _July 23, 2018_
+
+    * Dependencies updated
+
+## v1.0.0 - _July 20, 2018_
+
+    * Fix bug in string enum assertion. We erroneously were checking against the enum keys, not values (#821)
+
+## v0.2.14 - _July 18, 2018_
+
+    * Dependencies updated
+
+## v0.2.13 - _July 9, 2018_
+
+    * Dependencies updated
+
+## v0.2.12 - _June 19, 2018_
+
+    * Dependencies updated
+
+## v0.2.11 - _June 1, 2018_
+
+    * Incorrect publish that was unpublished
+
+## v0.2.10 - _May 22, 2018_
+
+    * Dependencies updated
+
+## v0.2.9 - _May 5, 2018_
+
+    * Dependencies updated
+
+## v0.2.8 - _May 4, 2018_
+
+    * Dependencies updated
+
+## v0.2.7 - _April 18, 2018_
+
+    * Dependencies updated
+
+## v0.2.6 - _April 11, 2018_
+
+    * Dependencies updated
+
+## v0.2.5 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.4 - _April 2, 2018_
+
+    * Dependencies updated
+
+## v0.2.0 - _March 7, 2018_
+
+    * Rename `isHttpUrl` to `isWebUri` (#412)
+
+## v0.1.0 - _March 3, 2018_
+
+    * Remove isETHAddressHex checksum address check and assume address will be lowercased  (#373)
+    * Add an optional parameter `subSchemas` to `doesConformToSchema` method (#385)
+
+## v0.0.18 - _February 8, 2017_
+
+    * Fix publishing issue where .npmignore was not properly excluding undesired content (#389)
+
+## v0.0.4 - _November 13, 2017_
 
     * Re-publish Assert previously published under NPM package @0xproject/0x-assert
     * Added assertion isValidBaseUnitAmount which checks both that the value is a valid bigNumber and that it does not contain decimals.

packages/assert/README.md

@@ -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,8 +46,22 @@ yarn install
 
 ### Build
 
+To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
+
 ```bash
-yarn build
+PKG=@0xproject/assert yarn build
+```
+
+Or continuously rebuild on change:
+
+```bash
+PKG=@0xproject/assert yarn watch
+```
+
+### Clean
+
+```bash
+yarn clean
 ```
 
 ### Lint