Publish

- @0xproject/0x.js@0.24.0
 - @0xproject/assert@0.0.4
 - @0xproject/json-schemas@0.6.7
 - @0xproject/tslint-config@0.1.0

.circleci/config.yml

@@ -0,0 +1,28 @@
+version: 2
+
+jobs:
+  build:
+    docker:
+      - image: circleci/node:6.12
+    environment:
+      CONTRACTS_COMMIT_HASH: '78fe8dd'
+    steps:
+      - checkout
+      - run: echo 'export PATH=$HOME/CIRCLE_PROJECT_REPONAME/node_modules/.bin:$PATH' >> $BASH_ENV
+      - run:
+          name: yarn
+          command: yarn
+      - save_cache:
+          key: dependency-cache-{{ checksum "package.json" }}
+          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 bootstrap
+      - run:
+          name: testrpc
+          command: npm run testrpc -- --db testrpc_snapshot
+          background: true
+      - run: yarn lerna:run test:circleci
+      - run: yarn lerna:run lint

.gitignore

@@ -58,9 +58,9 @@ typings/
 .env
 
 # built library using in commonjs module syntax
-lib
+lib/
 # UMD bundles that export the global variable
 _bundles
 
 # generated documentation
-docs
+docs/

README.md

@@ -4,7 +4,7 @@
 
 [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 a Javascript library that makes it easy to build Relayers and other DApps that use the 0x protocol.
+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.
 
 [![CircleCI](https://circleci.com/gh/0xProject/0x.js.svg?style=svg&circle-token=61bf7cd8c9b4e11b132089dfcffdd1be277d1e0c)](https://circleci.com/gh/0xProject/0x.js)
 [![npm version](https://badge.fury.io/js/0x.js.svg)](https://badge.fury.io/js/0x.js)
@@ -14,40 +14,25 @@ This repository contains a Javascript library that makes it easy to build Relaye
 [![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/)
 
-## Installation
+Instructions
+------------
 
-0x.js ships as both a [UMD](https://github.com/umdjs/umd) module and a [CommonJS](https://en.wikipedia.org/wiki/CommonJS) package.
+Make sure you have `yarn@1.x` installed locally.
 
-#### CommonJS *(recommended)*:
+### Creating a new sub-package
 
-**Install**
+1. Make sure the `name` field in the sub-package's `package.json` starts with `@0xproject/` and has a unique name (e.g `@0xproject/assert`).
+
+2. Run `yarn install` to install all it's dependencies.
+
+### How to add a sub-package as a dependency to another sub-package:
+
+1. Add the sub-packages name (declared in it's `package.json`) to your sub-packages `package.json` under `dependencies` or `devDependencies`.
+
+2. Run `yarn install` from anywhere in the mono repo.
+
+3. Import the sub-package as:
 
-```bash
-npm install 0x.js --save
 ```
-
-**Import**
-
-```javascript
-import {ZeroEx} from '0x.js';
+import {myPkg} from '@0xproject/myPkg';
 ```
-
-#### UMD:
-
-**Install**
-
-Download the UMD module from our [releases page](https://github.com/0xProject/0x.js/releases) and add it to your project.
-
-**Import**
-
-```html
-<script type="text/javascript" src="0x.js"></script>
-```
-
-## Documentation
-
-Extensive documentation of 0x.js can be found on [our website][docs-url].
-
-[website-url]: https://0xproject.com/
-[whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
-[docs-url]: https://0xproject.com/docs/0xjs

circle.yml

@@ -1,23 +0,0 @@
-machine:
-  node:
-    version: 6.5.0
-  environment:
-      CONTRACTS_COMMIT_HASH: '35053f9'
-      PATH: "${PATH}:${HOME}/${CIRCLE_PROJECT_REPONAME}/node_modules/.bin"
-
-dependencies:
-  override:
-    - yarn
-  cache_directories:
-    - ~/.cache/yarn
-
-test:
-  override:
-    - wget https://s3.amazonaws.com/testrpc-shapshots/${CONTRACTS_COMMIT_HASH}.zip
-    - unzip ${CONTRACTS_COMMIT_HASH}.zip -d testrpc_snapshot
-    - npm run testrpc -- --db testrpc_snapshot:
-        background: true
-    - yarn test:coverage
-    - yarn report_test_coverage
-    - if [ $CIRCLE_BRANCH = "master" ]; then yarn test:umd; fi
-    - yarn lint

lerna.json

@@ -0,0 +1,9 @@
+{
+  "lerna": "2.5.1",
+  "packages": [
+    "packages/*"
+  ],
+  "version": "independent",
+  "npmClient": "yarn",
+  "useWorkspaces": true
+}

package.json

@@ -1,108 +1,17 @@
 {
-  "name": "0x.js",
-  "version": "0.22.2",
-  "description": "A javascript library for interacting with the 0x protocol",
-  "keywords": [
-    "0x.js",
-    "0xproject",
-    "ethereum",
-    "tokens",
-    "exchange"
-  ],
-  "main": "lib/src/index.js",
-  "types": "lib/src/index.d.ts",
-  "scripts": {
-    "prebuild": "npm run clean",
-    "build": "run-p build:umd:prod build:commonjs",
-    "prepublishOnly": "run-p build",
-    "postpublish": "run-s release docs:json upload_docs_json",
-    "release": "publish-release --assets _bundles/index.js,_bundles/index.min.js --tag $(git describe --tags) --owner 0xProject --repo 0x.js",
-    "upload_docs_json": "aws s3 cp docs/index.json s3://0xjs-docs-jsons/$(git describe --tags).json --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type aplication/json",
-    "lint": "tslint src/**/*.ts test/**/*.ts",
-    "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;",
-    "testrpc": "testrpc -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
-    "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json docs/index.json .",
-    "docs:generate": "typedoc --out docs .",
-    "docs:open": "opn docs/index.html",
-    "clean": "shx rm -rf _bundles lib test_temp",
-    "build:umd:dev": "webpack",
-    "build:umd:prod": "NODE_ENV=production webpack",
-    "build:commonjs": "tsc; copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/artifacts;",
-    "test:commonjs": "run-s build:commonjs run_mocha",
-    "pretest:umd": "run-s clean build:umd:dev build:commonjs",
-    "substitute_umd_bundle": "npm run remove_src_files_not_used_by_tests; shx mv _bundles/* lib/src",
-    "remove_src_files_not_used_by_tests": "find ./lib/src \\( -path ./lib/src/utils -o -path ./lib/src/subproviders -o -path ./lib/src/schemas -o -path \"./lib/src/types.*\" \\) -prune -o -type f -print | xargs rm",
-    "run_mocha": "mocha lib/test/**/*_test.js --timeout 5000 --bail --exit"
-  },
-  "config": {
-    "artifacts": "TokenTransferProxy Exchange TokenRegistry Token EtherToken",
-    "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/0xProject/0x.js"
-  },
-  "license": "Apache-2.0",
-  "engines": {
-    "node": ">=6.0.0"
-  },
-  "devDependencies": {
-    "@types/jsonschema": "^1.1.1",
-    "@types/lodash": "^4.14.64",
-    "@types/mocha": "^2.2.41",
-    "@types/node": "^8.0.1",
-    "@types/sinon": "^2.2.2",
-    "@types/uuid": "^3.4.2",
-    "awesome-typescript-loader": "^3.1.3",
-    "bignumber.js": "^4.0.2",
-    "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.0",
-    "copyfiles": "^1.2.0",
-    "coveralls": "^3.0.0",
-    "dirty-chai": "^2.0.1",
-    "ethereumjs-testrpc": "4.0.1",
-    "json-loader": "^0.5.4",
-    "mocha": "^4.0.0",
-    "npm-run-all": "^4.0.2",
-    "nyc": "^11.0.1",
-    "opn-cli": "^3.1.0",
-    "request": "^2.81.0",
-    "request-promise-native": "^1.0.4",
-    "shx": "^0.2.2",
-    "sinon": "^4.0.0",
-    "source-map-support": "^0.5.0",
-    "truffle-hdwallet-provider": "^0.0.3",
-    "tslint": "^5.3.2",
-    "tslint-config-0xproject": "^0.0.2",
-    "typedoc": "^0.9.0",
-    "types-bn": "^0.0.1",
-    "types-ethereumjs-util": "0xProject/types-ethereumjs-util",
-    "typescript": "^2.4.1",
-    "web3-provider-engine": "^13.0.1",
-    "web3-typescript-typings": "^0.6.2",
-    "webpack": "^3.1.0"
-  },
-  "dependencies": {
-    "0x-json-schemas": "^0.6.1",
-    "@types/bignumber.js": "^4.0.2",
-    "bignumber.js": "^4.0.2",
-    "compare-versions": "^3.0.1",
-    "es6-promisify": "^5.0.0",
-    "ethereumjs-abi": "^0.6.4",
-    "ethereumjs-blockstream": "^2.0.6",
-    "ethereumjs-util": "^5.1.1",
-    "find-versions": "^2.0.0",
-    "js-sha3": "^0.6.1",
-    "lodash": "^4.17.4",
-    "publish-release": "^1.3.3",
-    "uuid": "^3.1.0",
-    "web3": "^0.20.0"
-  }
+    "private": true,
+    "name": "0x.js",
+    "workspaces": [
+        "packages/*"
+    ],
+    "scripts": {
+        "testrpc": "testrpc -p 8545 --networkId 50 -m \"${npm_package_config_mnemonic}\"",
+        "lerna:run": "lerna run"
+    },
+    "config": {
+      "mnemonic": "concert load couple harbor equip island argue ramp clarify fence smart topic"
+    },
+    "devDependencies": {
+        "lerna": "^2.5.1"
+    }
 }

packages/0x.js/CHANGELOG.md

@@ -1,5 +1,31 @@
 # CHANGELOG
 
+v0.24.0 - _November 13, 2017_
+------------------------
+    * Standardise on Cancelled over Canceled
+    * Add missing `DecodedLogEvent` type to exported types
+
+v0.23.0 - _November 12, 2017_
+------------------------
+    *  Fixed unhandled promise rejection error in subscribe methods (#209)
+        * Subscribe callbacks now receive an error object as their first argument
+
+v0.22.6 - _November 10, 2017_
+------------------------
+    * Add a timeout parameter to transaction awaiting (#206)
+
+v0.22.5 - _November 7, 2017_
+------------------------
+    * Re-publish v0.22.4 to fix publishing issue
+
+v0.22.4 - _October 25, 2017_
+------------------------
+    * Upgraded bignumber.js to a new version that ships with native typings
+
+v0.22.3 - _October 25, 2017_
+------------------------
+    * Fixed an issue with new version of testrpc and unlimited proxy allowance (#199)
+
 v0.22.2 - _October 24, 2017_
 ------------------------
     * Fixed rounding of maker fill amount and incorrect validation of partial fees (#197)

packages/0x.js/README.md

@@ -0,0 +1,37 @@
+## Installation
+
+0x.js ships as both a [UMD](https://github.com/umdjs/umd) module and a [CommonJS](https://en.wikipedia.org/wiki/CommonJS) package.
+
+#### CommonJS *(recommended)*:
+
+**Install**
+
+```bash
+npm install 0x.js --save
+```
+
+**Import**
+
+```javascript
+import {ZeroEx} from '0x.js';
+```
+
+#### UMD:
+
+**Install**
+
+Download the UMD module from our [releases page](https://github.com/0xProject/0x.js/releases) and add it to your project.
+
+**Import**
+
+```html
+<script type="text/javascript" src="0x.js"></script>
+```
+
+## Documentation
+
+Extensive documentation of 0x.js can be found on [our website][docs-url].
+
+[website-url]: https://0xproject.com/
+[whitepaper-url]: https://0xproject.com/pdfs/0x_white_paper.pdf
+[docs-url]: https://0xproject.com/docs/0xjs

packages/0x.js/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@0xproject/0x.js",
+  "version": "0.24.0",
+  "description": "A javascript library for interacting with the 0x protocol",
+  "keywords": [
+    "0x.js",
+    "0xproject",
+    "ethereum",
+    "tokens",
+    "exchange"
+  ],
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "scripts": {
+    "prebuild": "npm run clean",
+    "build": "run-p build:umd:prod build:commonjs; exit 0;",
+    "prepublishOnly": "run-p build",
+    "postpublish": "run-s release docs:json upload_docs_json",
+    "release": "publish-release --assets _bundles/index.js,_bundles/index.min.js --tag $(git describe --tags) --owner 0xProject --repo 0x.js",
+    "upload_docs_json": "aws s3 cp docs/index.json s3://0xjs-docs-jsons/$(git describe --tags).json --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type aplication/json",
+    "lint": "tslint src/**/*.ts test/**/*.ts",
+    "test:circleci": "run-s test:coverage report_test_coverage; if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi",
+    "test": "run-s clean test:commonjs",
+    "test:umd": "./scripts/test_umd.sh",
+    "test:coverage": "nyc npm run test --all",
+    "report_test_coverage": "nyc report --reporter=text-lcov | coveralls",
+    "update_contracts": "for i in ${npm_package_config_artifacts}; do copyfiles -u 4 ../contracts/build/contracts/$i.json ../0x.js/src/artifacts; done;",
+    "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json docs/index.json .",
+    "docs:generate": "typedoc --out docs .",
+    "docs:open": "opn docs/index.html",
+    "clean": "shx rm -rf _bundles lib test_temp",
+    "build:umd:dev": "webpack",
+    "build:umd:prod": "NODE_ENV=production webpack",
+    "build:commonjs": "tsc && copyfiles -u 2 './src/artifacts/**/*.json' ./lib/src/artifacts;",
+    "test:commonjs": "run-s build:commonjs run_mocha",
+    "pretest:umd": "run-s clean build:umd:dev build:commonjs",
+    "substitute_umd_bundle": "shx mv _bundles/* lib/src",
+    "run_mocha": "mocha lib/test/**/*_test.js --timeout 5000 --bail --exit"
+  },
+  "config": {
+    "artifacts": "TokenTransferProxy Exchange TokenRegistry Token EtherToken"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xProject/0x.js"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@0xproject/tslint-config": "^0.1.0",
+    "@types/jsonschema": "^1.1.1",
+    "@types/lodash": "^4.14.64",
+    "@types/mocha": "^2.2.41",
+    "@types/node": "^8.0.1",
+    "@types/sinon": "^2.2.2",
+    "@types/uuid": "^3.4.2",
+    "awesome-typescript-loader": "^3.1.3",
+    "chai": "^4.0.1",
+    "chai-as-promised": "^7.1.0",
+    "chai-as-promised-typescript-typings": "0.0.3",
+    "chai-bignumber": "^2.0.1",
+    "chai-typescript-typings": "^0.0.1",
+    "copyfiles": "^1.2.0",
+    "coveralls": "^3.0.0",
+    "dirty-chai": "^2.0.1",
+    "ethereumjs-testrpc": "4.0.1",
+    "json-loader": "^0.5.4",
+    "mocha": "^4.0.0",
+    "npm-run-all": "^4.0.2",
+    "nyc": "^11.0.1",
+    "opn-cli": "^3.1.0",
+    "request": "^2.81.0",
+    "request-promise-native": "^1.0.4",
+    "shx": "^0.2.2",
+    "sinon": "^4.0.0",
+    "source-map-support": "^0.5.0",
+    "truffle-hdwallet-provider": "^0.0.3",
+    "tslint": "5.8.0",
+    "typedoc": "~0.8.0",
+    "types-bn": "^0.0.1",
+    "types-ethereumjs-util": "0xProject/types-ethereumjs-util",
+    "typescript": "~2.6.1",
+    "web3-provider-engine": "^13.0.1",
+    "web3-typescript-typings": "^0.7.1",
+    "webpack": "^3.1.0"
+  },
+  "dependencies": {
+    "@0xproject/assert": "^0.0.4",
+    "@0xproject/json-schemas": "^0.6.7",
+    "bignumber.js": "~4.1.0",
+    "bn.js": "4.11.8",
+    "compare-versions": "^3.0.1",
+    "es6-promisify": "^5.0.0",
+    "ethereumjs-abi": "^0.6.4",
+    "ethereumjs-blockstream": "^2.0.6",
+    "ethereumjs-util": "^5.1.1",
+    "find-versions": "^2.0.0",
+    "js-sha3": "^0.6.1",
+    "lodash": "^4.17.4",
+    "publish-release": "^1.3.3",
+    "uuid": "^3.1.0",
+    "web3": "^0.20.0"
+  }
+}

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

@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
-import * as BigNumber from 'bignumber.js';
-import {SchemaValidator, schemas} from '0x-json-schemas';
+import BigNumber from 'bignumber.js';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
 import {bigNumberConfigs} from './bignumber_config';
 import * as ethUtil from 'ethereumjs-util';
 import {Web3Wrapper} from './web3_wrapper';
@@ -16,6 +16,8 @@ import {TokenRegistryWrapper} from './contract_wrappers/token_registry_wrapper';
 import {EtherTokenWrapper} from './contract_wrappers/ether_token_wrapper';
 import {TokenWrapper} from './contract_wrappers/token_wrapper';
 import {TokenTransferProxyWrapper} from './contract_wrappers/token_transfer_proxy_wrapper';
+import {OrderStateWatcher} from './order_watcher/order_state_watcher';
+import {OrderStateUtils} from './utils/order_state_utils';
 import {
     ECSignature,
     ZeroExError,
@@ -23,6 +25,7 @@ import {
     SignedOrder,
     Web3Provider,
     ZeroExConfig,
+    OrderStateWatcherConfig,
     TransactionReceiptWithDecodedLogs,
 } from './types';
 import {zeroExConfigSchema} from './schemas/zero_ex_config_schema';
@@ -65,6 +68,11 @@ export class ZeroEx {
      * tokenTransferProxy smart contract.
      */
     public proxy: TokenTransferProxyWrapper;
+    /**
+     * An instance of the OrderStateWatcher class containing methods for watching a set of orders for relevant
+     * blockchain state changes.
+     */
+    public orderStateWatcher: OrderStateWatcher;
     private _web3Wrapper: Web3Wrapper;
     private _abiDecoder: AbiDecoder;
     /**
@@ -80,19 +88,8 @@ export class ZeroEx {
         assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
         assert.isETHAddressHex('signerAddress', signerAddress);
 
-        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;
-        }
+        const isValidSignature = signatureUtils.isValidSignature(data, signature, signerAddress);
+        return isValidSignature;
     }
     /**
      * Generates a pseudo-random 256-bit salt.
@@ -100,7 +97,7 @@ export class ZeroEx {
      * 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 {
+    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);
@@ -131,7 +128,7 @@ export class ZeroEx {
      * @param   decimals    The number of decimal places the unit amount has.
      * @return  The amount in units.
      */
-    public static toUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+    public static toUnitAmount(amount: BigNumber, decimals: number): BigNumber {
         assert.isBigNumber('amount', amount);
         assert.isNumber('decimals', decimals);
 
@@ -147,7 +144,7 @@ export class ZeroEx {
      * @param   decimals    The number of decimal places the unit amount has.
      * @return  The amount in baseUnits.
      */
-    public static toBaseUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+    public static toBaseUnitAmount(amount: BigNumber, decimals: number): BigNumber {
         assert.isBigNumber('amount', amount);
         assert.isNumber('decimals', decimals);
 
@@ -177,12 +174,6 @@ export class ZeroEx {
         if (!_.isUndefined(config)) {
             assert.doesConformToSchema('config', config, zeroExConfigSchema);
         }
-        if (_.isUndefined((provider as any).sendAsync)) {
-            // Web3@1.0 provider doesn't support synchronous http requests,
-            // so it only has an async `send` method, instead of a `send` and `sendAsync` in web3@0.x.x`
-            // We re-assign the send method so that Web3@1.0 providers work with 0x.js
-            (provider as any).sendAsync = (provider as any).send;
-        }
         const artifactJSONs = _.values(artifacts);
         const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
         this._abiDecoder = new AbiDecoder(abiArrays);
@@ -213,6 +204,10 @@ export class ZeroEx {
         this.tokenRegistry = new TokenRegistryWrapper(this._web3Wrapper, tokenRegistryContractAddressIfExists);
         const etherTokenContractAddressIfExists = _.isUndefined(config) ? undefined : config.etherTokenContractAddress;
         this.etherToken = new EtherTokenWrapper(this._web3Wrapper, this.token, etherTokenContractAddressIfExists);
+        const orderWatcherConfig = _.isUndefined(config) ? undefined : config.orderWatcherConfig;
+        this.orderStateWatcher = new OrderStateWatcher(
+            this._web3Wrapper, this._abiDecoder, this.token, this.exchange, orderWatcherConfig,
+        );
     }
     /**
      * Sets a new web3 provider for 0x.js. Updating the provider will stop all
@@ -289,13 +284,24 @@ export class ZeroEx {
      * 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: number = 1000): Promise<TransactionReceiptWithDecodedLogs> {
+        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);
@@ -311,6 +317,7 @@ export class ZeroEx {
                 }
             }, pollingIntervalMs);
         });
+
         return txReceiptPromise;
     }
     /*

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

@@ -1,4 +1,4 @@
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 
 export const bigNumberConfigs = {
     configure() {

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

@@ -1,7 +1,7 @@
 import * as Web3 from 'web3';
 import * as _ from 'lodash';
 import promisify = require('es6-promisify');
-import {SchemaValidator, schemas} from '0x-json-schemas';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
 import {AbiType} from './types';
 
 export class Contract implements Web3.ContractInstance {

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

@@ -38,6 +38,29 @@ export class ContractWrapper {
         this._onLogAddedSubscriptionToken = undefined;
         this._onLogRemovedSubscriptionToken = undefined;
     }
+    /**
+     * Cancels all existing subscriptions
+     */
+    public unsubscribeAll(): void {
+        const filterTokens = _.keys(this._filterCallbacks);
+        _.each(filterTokens, filterToken => {
+            this._unsubscribe(filterToken);
+        });
+    }
+    protected _unsubscribe(filterToken: string, err?: Error): void {
+        if (_.isUndefined(this._filters[filterToken])) {
+            throw new Error(ZeroExError.SubscriptionNotFound);
+        }
+        if (!_.isUndefined(err)) {
+            const callback = this._filterCallbacks[filterToken];
+            callback(err, undefined);
+        }
+        delete this._filters[filterToken];
+        delete this._filterCallbacks[filterToken];
+        if (_.isEmpty(this._filters)) {
+            this._stopBlockAndLogStream();
+        }
+    }
     protected _subscribe<ArgsType extends ContractEventArgs>(
         address: string, eventName: ContractEvents, indexFilterValues: IndexedFilterValues, abi: Web3.ContractAbi,
         callback: EventCallback<ArgsType>): string {
@@ -50,16 +73,6 @@ export class ContractWrapper {
         this._filterCallbacks[filterToken] = callback;
         return filterToken;
     }
-    protected _unsubscribe(filterToken: string): void {
-        if (_.isUndefined(this._filters[filterToken])) {
-            throw new Error(ZeroExError.SubscriptionNotFound);
-        }
-        delete this._filters[filterToken];
-        delete this._filterCallbacks[filterToken];
-        if (_.isEmpty(this._filters)) {
-            this._stopBlockAndLogStream();
-        }
-    }
     protected async _getLogsAsync<ArgsType extends ContractEventArgs>(
         address: string, eventName: ContractEvents, subscriptionOpts: SubscriptionOpts,
         indexFilterValues: IndexedFilterValues, abi: Web3.ContractAbi): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
@@ -90,7 +103,7 @@ export class ContractWrapper {
                     ...decodedLog,
                     removed,
                 };
-                this._filterCallbacks[filterToken](logEvent);
+                this._filterCallbacks[filterToken](null, logEvent);
             }
         });
     }
@@ -122,11 +135,18 @@ export class ContractWrapper {
         delete this._blockAndLogStreamer;
     }
     private async _reconcileBlockAsync(): Promise<void> {
-        const latestBlock = await this._web3Wrapper.getBlockAsync(BlockParamLiteral.Latest);
-        // We need to coerce to Block type cause Web3.Block includes types for mempool blocks
-        if (!_.isUndefined(this._blockAndLogStreamer)) {
-            // If we clear the interval while fetching the block - this._blockAndLogStreamer will be undefined
-            this._blockAndLogStreamer.reconcileNewBlock(latestBlock as any as Block);
+        try {
+            const latestBlock = await this._web3Wrapper.getBlockAsync(BlockParamLiteral.Latest);
+            // We need to coerce to Block type cause Web3.Block includes types for mempool blocks
+            if (!_.isUndefined(this._blockAndLogStreamer)) {
+                // If we clear the interval while fetching the block - this._blockAndLogStreamer will be undefined
+                this._blockAndLogStreamer.reconcileNewBlock(latestBlock as any as Block);
+            }
+        } catch (err) {
+            const filterTokens = _.keys(this._filterCallbacks);
+            _.each(filterTokens, filterToken => {
+                this._unsubscribe(filterToken, err);
+            });
         }
     }
 }

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

@@ -1,4 +1,5 @@
 import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
 import {Web3Wrapper} from '../web3_wrapper';
 import {ContractWrapper} from './contract_wrapper';
 import {TokenWrapper} from './token_wrapper';
@@ -27,8 +28,8 @@ export class EtherTokenWrapper extends ContractWrapper {
      * @param   depositor   The hex encoded user Ethereum address that would like to make the deposit.
      * @return Transaction hash.
      */
-    public async depositAsync(amountInWei: BigNumber.BigNumber, depositor: string): Promise<string> {
-        assert.isBigNumber('amountInWei', amountInWei);
+    public async depositAsync(amountInWei: BigNumber, depositor: string): Promise<string> {
+        assert.isValidBaseUnitAmount('amountInWei', amountInWei);
         await assert.isSenderAddressAsync('depositor', depositor, this._web3Wrapper);
 
         const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(depositor);
@@ -48,8 +49,8 @@ export class EtherTokenWrapper extends ContractWrapper {
      * @param   withdrawer   The hex encoded user Ethereum address that would like to make the withdrawl.
      * @return Transaction hash.
      */
-    public async withdrawAsync(amountInWei: BigNumber.BigNumber, withdrawer: string): Promise<string> {
-        assert.isBigNumber('amountInWei', amountInWei);
+    public async withdrawAsync(amountInWei: BigNumber, withdrawer: string): Promise<string> {
+        assert.isValidBaseUnitAmount('amountInWei', amountInWei);
         await assert.isSenderAddressAsync('withdrawer', withdrawer, this._web3Wrapper);
 
         const wethContractAddress = await this.getContractAddressAsync();

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

@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
-import {schemas} from '0x-json-schemas';
+import BigNumber from 'bignumber.js';
+import {schemas} from '@0xproject/json-schemas';
 import {Web3Wrapper} from '../web3_wrapper';
 import {
     ECSignature,
@@ -13,7 +13,6 @@ import {
     OrderAddresses,
     Order,
     SignedOrder,
-    ContractEvent,
     ExchangeEvents,
     SubscriptionOpts,
     IndexedFilterValues,
@@ -43,16 +42,19 @@ import {artifacts} from '../artifacts';
 
 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 _activeSubscriptions: string[];
     private _orderValidationUtils: OrderValidationUtils;
     private _tokenWrapper: TokenWrapper;
-    private _exchangeContractErrCodesToMsg = {
+    private _exchangeContractErrCodesToMsg: ExchangeContractErrCodesToMsgs = {
         [ExchangeContractErrCodes.ERROR_FILL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
         [ExchangeContractErrCodes.ERROR_CANCEL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
         [ExchangeContractErrCodes.ERROR_FILL_NO_VALUE]: ExchangeContractErrs.OrderRemainingFillAmountZero,
@@ -84,7 +86,6 @@ export class ExchangeWrapper extends ContractWrapper {
         super(web3Wrapper, abiDecoder);
         this._tokenWrapper = tokenWrapper;
         this._orderValidationUtils = new OrderValidationUtils(tokenWrapper, this);
-        this._activeSubscriptions = [];
         this._contractAddressIfExists = contractAddressIfExists;
     }
     /**
@@ -94,10 +95,10 @@ export class ExchangeWrapper extends ContractWrapper {
      * @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 canceled.
+     * @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.BigNumber> {
+                                                methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync();
@@ -115,7 +116,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @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.BigNumber> {
+    public async getFilledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync();
@@ -132,7 +133,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   methodOpts   Optional arguments this method accepts.
      * @return  The amount of the order (in taker tokens) that has been cancelled.
      */
-    public async getCanceledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber.BigNumber> {
+    public async getCancelledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
 
         const exchangeContract = await this._getExchangeContractAsync();
@@ -162,12 +163,12 @@ export class ExchangeWrapper extends ContractWrapper {
      * @return  Transaction hash.
      */
     @decorators.contractCallErrorHandler
-    public async fillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber.BigNumber,
+    public async fillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber,
                                 shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                                 takerAddress: string,
                                 orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
+        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
 
@@ -229,7 +230,7 @@ export class ExchangeWrapper extends ContractWrapper {
      * @return  Transaction hash.
      */
     @decorators.contractCallErrorHandler
-    public async fillOrdersUpToAsync(signedOrders: SignedOrder[], fillTakerTokenAmount: BigNumber.BigNumber,
+    public async fillOrdersUpToAsync(signedOrders: SignedOrder[], fillTakerTokenAmount: BigNumber,
                                      shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                                      takerAddress: string,
                                      orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
@@ -240,7 +241,7 @@ export class ExchangeWrapper extends ContractWrapper {
         const exchangeContractAddresses = _.map(signedOrders, signedOrder => signedOrder.exchangeContractAddress);
         assert.hasAtMostOneUniqueValue(exchangeContractAddresses,
                                        ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress);
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
+        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
 
@@ -304,9 +305,9 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Batch version of fillOrderAsync.
      * Executes multiple fills atomically in a single transaction.
-     * If shouldThrowOnInsufficientBalanceOrAllowance is set to true, it will continue filling subsequent orders even
+     * If shouldThrowOnInsufficientBalanceOrAllowance is set to false, it will continue filling subsequent orders even
      * when earlier ones fail.
-     * When shouldThrowOnInsufficientBalanceOrAllowance is set to false, if any fill fails, the entire batch fails.
+     * 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
@@ -405,11 +406,11 @@ export class ExchangeWrapper extends ContractWrapper {
      * @return  Transaction hash.
      */
     @decorators.contractCallErrorHandler
-    public async fillOrKillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber.BigNumber,
+    public async fillOrKillOrderAsync(signedOrder: SignedOrder, fillTakerTokenAmount: BigNumber,
                                       takerAddress: string,
                                       orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
+        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
 
         const exchangeInstance = await this._getExchangeContractAsync();
@@ -541,10 +542,10 @@ export class ExchangeWrapper extends ContractWrapper {
      */
     @decorators.contractCallErrorHandler
     public async cancelOrderAsync(order: Order|SignedOrder,
-                                  cancelTakerTokenAmount: BigNumber.BigNumber,
+                                  cancelTakerTokenAmount: BigNumber,
                                   orderTransactionOpts?: OrderTransactionOpts): Promise<string> {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
-        assert.isBigNumber('takerTokenCancelAmount', cancelTakerTokenAmount);
+        assert.isValidBaseUnitAmount('takerTokenCancelAmount', cancelTakerTokenAmount);
         await assert.isSenderAddressAsync('order.maker', order.maker, this._web3Wrapper);
 
         const exchangeInstance = await this._getExchangeContractAsync();
@@ -666,7 +667,6 @@ export class ExchangeWrapper extends ContractWrapper {
         const subscriptionToken = this._subscribe<ArgsType>(
             exchangeContractAddress, eventName, indexFilterValues, artifacts.ExchangeArtifact.abi, callback,
         );
-        this._activeSubscriptions.push(subscriptionToken);
         return subscriptionToken;
     }
     /**
@@ -674,7 +674,6 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   subscriptionToken Subscription token returned by `subscribe()`
      */
     public unsubscribe(subscriptionToken: string): void {
-        _.pull(this._activeSubscriptions, subscriptionToken);
         this._unsubscribe(subscriptionToken);
     }
     /**
@@ -736,10 +735,10 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async validateFillOrderThrowIfInvalidAsync(signedOrder: SignedOrder,
-                                                      fillTakerTokenAmount: BigNumber.BigNumber,
+                                                      fillTakerTokenAmount: BigNumber,
                                                       takerAddress: string): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
+        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
         const zrxTokenAddress = await this.getZRXTokenAddressAsync();
         const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
@@ -753,9 +752,9 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   cancelTakerTokenAmount  The amount (specified in taker tokens) that you would like to cancel.
      */
     public async validateCancelOrderThrowIfInvalidAsync(
-        order: Order, cancelTakerTokenAmount: BigNumber.BigNumber): Promise<void> {
+        order: Order, cancelTakerTokenAmount: BigNumber): Promise<void> {
         assert.doesConformToSchema('order', order, schemas.orderSchema);
-        assert.isBigNumber('cancelTakerTokenAmount', cancelTakerTokenAmount);
+        assert.isValidBaseUnitAmount('cancelTakerTokenAmount', cancelTakerTokenAmount);
         const orderHash = utils.getOrderHashHex(order);
         const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
         await this._orderValidationUtils.validateCancelOrderThrowIfInvalidAsync(
@@ -770,10 +769,10 @@ export class ExchangeWrapper extends ContractWrapper {
      *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async validateFillOrKillOrderThrowIfInvalidAsync(signedOrder: SignedOrder,
-                                                            fillTakerTokenAmount: BigNumber.BigNumber,
+                                                            fillTakerTokenAmount: BigNumber,
                                                             takerAddress: string): Promise<void> {
         assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
+        assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
         await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
         const zrxTokenAddress = await this.getZRXTokenAddressAsync();
         const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper);
@@ -789,12 +788,12 @@ export class ExchangeWrapper extends ContractWrapper {
      * @param   takerTokenAmount       The order size on the taker side
      * @param   makerTokenAmount       The order size on the maker side
      */
-    public async isRoundingErrorAsync(fillTakerTokenAmount: BigNumber.BigNumber,
-                                      takerTokenAmount: BigNumber.BigNumber,
-                                      makerTokenAmount: BigNumber.BigNumber): Promise<boolean> {
-        assert.isBigNumber('fillTakerTokenAmount', fillTakerTokenAmount);
-        assert.isBigNumber('takerTokenAmount', takerTokenAmount);
-        assert.isBigNumber('makerTokenAmount', makerTokenAmount);
+    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,
@@ -825,13 +824,6 @@ export class ExchangeWrapper extends ContractWrapper {
         const ZRXtokenAddress = await exchangeInstance.ZRX_TOKEN_CONTRACT.callAsync();
         return ZRXtokenAddress;
     }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        _.forEach(this._activeSubscriptions, this._unsubscribe.bind(this));
-        this._activeSubscriptions = [];
-    }
     private async _invalidateContractInstancesAsync(): Promise<void> {
         this.unsubscribeAll();
         delete this._exchangeContractIfExists;

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

@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
-import * as BigNumber from 'bignumber.js';
-import {schemas} from '0x-json-schemas';
+import BigNumber from 'bignumber.js';
+import {schemas} from '@0xproject/json-schemas';
 import {Web3Wrapper} from '../web3_wrapper';
 import {assert} from '../utils/assert';
 import {constants} from '../utils/constants';
@@ -19,7 +19,7 @@ import {
     TokenContractEventArgs,
 } from '../types';
 
-const ALLOWANCE_TO_ZERO_GAS_AMOUNT = 47155;
+const ALLOWANCE_TO_ZERO_GAS_AMOUNT = 47275;
 
 /**
  * This class includes all the functionality related to interacting with ERC20 token contracts.
@@ -29,13 +29,11 @@ const ALLOWANCE_TO_ZERO_GAS_AMOUNT = 47155;
 export class TokenWrapper extends ContractWrapper {
     public UNLIMITED_ALLOWANCE_IN_BASE_UNITS = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
     private _tokenContractsByAddress: {[address: string]: TokenContract};
-    private _activeSubscriptions: string[];
     private _tokenTransferProxyContractAddressFetcher: () => Promise<string>;
     constructor(web3Wrapper: Web3Wrapper, abiDecoder: AbiDecoder,
                 tokenTransferProxyContractAddressFetcher: () => Promise<string>) {
         super(web3Wrapper, abiDecoder);
         this._tokenContractsByAddress = {};
-        this._activeSubscriptions = [];
         this._tokenTransferProxyContractAddressFetcher = tokenTransferProxyContractAddressFetcher;
     }
     /**
@@ -46,7 +44,7 @@ export class TokenWrapper extends ContractWrapper {
      * @return  The owner's ERC20 token balance in base units.
      */
     public async getBalanceAsync(tokenAddress: string, ownerAddress: string,
-                                 methodOpts?: MethodOpts): Promise<BigNumber.BigNumber> {
+                                 methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
 
@@ -68,11 +66,11 @@ export class TokenWrapper extends ContractWrapper {
      * @return Transaction hash.
      */
     public async setAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string,
-                                   amountInBaseUnits: BigNumber.BigNumber): Promise<string> {
+                                   amountInBaseUnits: BigNumber): Promise<string> {
         await assert.isSenderAddressAsync('ownerAddress', ownerAddress, this._web3Wrapper);
         assert.isETHAddressHex('spenderAddress', spenderAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
+        assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
         const tokenContract = await this._getTokenContractAsync(tokenAddress);
         // Hack: for some reason default estimated gas amount causes `base fee exceeds gas limit` exception
@@ -113,7 +111,7 @@ export class TokenWrapper extends ContractWrapper {
      * @param   methodOpts      Optional arguments this method accepts.
      */
     public async getAllowanceAsync(tokenAddress: string, ownerAddress: string,
-                                   spenderAddress: string, methodOpts?: MethodOpts): Promise<BigNumber.BigNumber> {
+                                   spenderAddress: string, methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
 
@@ -131,7 +129,7 @@ export class TokenWrapper extends ContractWrapper {
      * @param   methodOpts      Optional arguments this method accepts.
      */
     public async getProxyAllowanceAsync(tokenAddress: string, ownerAddress: string,
-                                        methodOpts?: MethodOpts): Promise<BigNumber.BigNumber> {
+                                        methodOpts?: MethodOpts): Promise<BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
 
@@ -149,10 +147,10 @@ export class TokenWrapper extends ContractWrapper {
      * @return Transaction hash.
      */
     public async setProxyAllowanceAsync(tokenAddress: string, ownerAddress: string,
-                                        amountInBaseUnits: BigNumber.BigNumber): Promise<string> {
+                                        amountInBaseUnits: BigNumber): Promise<string> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
         assert.isETHAddressHex('tokenAddress', tokenAddress);
-        assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
+        assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
         const proxyAddress = await this._getTokenTransferProxyAddressAsync();
         const txHash = await this.setAllowanceAsync(tokenAddress, ownerAddress, proxyAddress, amountInBaseUnits);
@@ -183,11 +181,11 @@ export class TokenWrapper extends ContractWrapper {
      * @return Transaction hash.
      */
     public async transferAsync(tokenAddress: string, fromAddress: string, toAddress: string,
-                               amountInBaseUnits: BigNumber.BigNumber): Promise<string> {
+                               amountInBaseUnits: BigNumber): Promise<string> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
         await assert.isSenderAddressAsync('fromAddress', fromAddress, this._web3Wrapper);
         assert.isETHAddressHex('toAddress', toAddress);
-        assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
+        assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
         const tokenContract = await this._getTokenContractAsync(tokenAddress);
 
@@ -215,13 +213,13 @@ export class TokenWrapper extends ContractWrapper {
      * @return Transaction hash.
      */
     public async transferFromAsync(tokenAddress: string, fromAddress: string, toAddress: string,
-                                   senderAddress: string, amountInBaseUnits: BigNumber.BigNumber):
+                                   senderAddress: string, amountInBaseUnits: BigNumber):
                                    Promise<string> {
         assert.isETHAddressHex('tokenAddress', tokenAddress);
         assert.isETHAddressHex('fromAddress', fromAddress);
         assert.isETHAddressHex('toAddress', toAddress);
         await assert.isSenderAddressAsync('senderAddress', senderAddress, this._web3Wrapper);
-        assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
+        assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
 
         const tokenContract = await this._getTokenContractAsync(tokenAddress);
 
@@ -262,7 +260,6 @@ export class TokenWrapper extends ContractWrapper {
         const subscriptionToken = this._subscribe<ArgsType>(
             tokenAddress, eventName, indexFilterValues, artifacts.TokenArtifact.abi, callback,
         );
-        this._activeSubscriptions.push(subscriptionToken);
         return subscriptionToken;
     }
     /**
@@ -270,7 +267,6 @@ export class TokenWrapper extends ContractWrapper {
      * @param   subscriptionToken Subscription token returned by `subscribe()`
      */
     public unsubscribe(subscriptionToken: string): void {
-        _.pull(this._activeSubscriptions, subscriptionToken);
         this._unsubscribe(subscriptionToken);
     }
     /**
@@ -294,13 +290,6 @@ export class TokenWrapper extends ContractWrapper {
         );
         return logs;
     }
-    /**
-     * Cancels all existing subscriptions
-     */
-    public unsubscribeAll(): void {
-        _.forEach(this._activeSubscriptions, this._unsubscribe.bind(this));
-        this._activeSubscriptions = [];
-    }
     private _invalidateContractInstancesAsync(): void {
         this.unsubscribeAll();
         this._tokenContractsByAddress = {};

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

@@ -12,12 +12,6 @@ declare module 'web3-provider-engine/subproviders/rpc';
 // disallow `namespace`, we disable tslint for the following.
 /* tslint:disable */
 declare namespace Chai {
-    interface NumberComparer {
-        (value: number|BigNumber.BigNumber, message?: string): Assertion;
-    }
-    interface NumericComparison {
-        greaterThan: NumberComparer;
-    }
     interface Assertion {
         bignumber: Assertion;
         // HACK: In order to comply with chai-as-promised we make eventually a `PromisedAssertion` not an `Assertion`
@@ -70,8 +64,6 @@ declare module 'truffle-hdwallet-provider' {
 
 // abi-decoder declarations
 interface DecodedLogArg {
-    name: string;
-    value: string|BigNumber.BigNumber;
 }
 interface DecodedLog {
     name: string;

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

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

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

@@ -29,10 +29,17 @@ export {
     ContractEventArg,
     Web3Provider,
     ZeroExConfig,
+    TransactionReceipt,
     TransactionReceiptWithDecodedLogs,
     LogWithDecodedArgs,
     MethodOpts,
     OrderTransactionOpts,
     FilterObject,
     LogEvent,
+    DecodedLogEvent,
+    EventWatcherCallback,
+    OnOrderStateChangeCallback,
+    OrderStateValid,
+    OrderStateInvalid,
+    OrderState,
 } from './types';

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

@@ -0,0 +1,88 @@
+import * as Web3 from 'web3';
+import * as _ from 'lodash';
+import {Web3Wrapper} from '../web3_wrapper';
+import {
+    BlockParamLiteral,
+    EventCallback,
+    EventWatcherCallback,
+    ZeroExError,
+} from '../types';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {intervalUtils} from '../utils/interval_utils';
+import {assert} from '../utils/assert';
+import {utils} from '../utils/utils';
+
+const DEFAULT_EVENT_POLLING_INTERVAL = 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, pollingIntervalMs: undefined|number) {
+        this._web3Wrapper = web3Wrapper;
+        this._pollingIntervalMs = _.isUndefined(pollingIntervalMs) ?
+                                    DEFAULT_EVENT_POLLING_INTERVAL :
+                                    pollingIntervalMs;
+    }
+    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)) {
+                await callback(logEvent);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,231 @@
+import * as _ from 'lodash';
+import {schemas} from '@0xproject/json-schemas';
+import {ZeroEx} from '../0x';
+import {EventWatcher} from './event_watcher';
+import {assert} from '../utils/assert';
+import {utils} from '../utils/utils';
+import {artifacts} from '../artifacts';
+import {AbiDecoder} from '../utils/abi_decoder';
+import {OrderStateUtils} from '../utils/order_state_utils';
+import {
+    LogEvent,
+    OrderState,
+    SignedOrder,
+    Web3Provider,
+    BlockParamLiteral,
+    LogWithDecodedArgs,
+    ContractEventArgs,
+    OnOrderStateChangeCallback,
+    OrderStateWatcherConfig,
+    ApprovalContractEventArgs,
+    TransferContractEventArgs,
+    LogFillContractEventArgs,
+    LogCancelContractEventArgs,
+    ExchangeEvents,
+    TokenEvents,
+    ZeroExError,
+} from '../types';
+import {Web3Wrapper} from '../web3_wrapper';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {OrderFilledCancelledLazyStore} from '../stores/order_filled_cancelled_lazy_store';
+import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
+
+const DEFAULT_NUM_CONFIRMATIONS = 0;
+
+interface DependentOrderHashes {
+    [makerAddress: string]: {
+        [makerToken: string]: Set<string>,
+    };
+}
+
+interface OrderByOrderHash {
+    [orderHash: string]: SignedOrder;
+}
+
+/**
+ * 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 _orderByOrderHash: OrderByOrderHash = {};
+    private _dependentOrderHashes: DependentOrderHashes = {};
+    private _callbackIfExistsAsync?: OnOrderStateChangeCallback;
+    private _eventWatcher: EventWatcher;
+    private _web3Wrapper: Web3Wrapper;
+    private _abiDecoder: AbiDecoder;
+    private _orderStateUtils: OrderStateUtils;
+    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
+    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
+    constructor(
+        web3Wrapper: Web3Wrapper, abiDecoder: AbiDecoder, token: TokenWrapper, exchange: ExchangeWrapper,
+        config?: OrderStateWatcherConfig,
+    ) {
+        this._abiDecoder = abiDecoder;
+        this._web3Wrapper = web3Wrapper;
+        const eventPollingIntervalMs = _.isUndefined(config) ? undefined : config.eventPollingIntervalMs;
+        this._eventWatcher = new EventWatcher(web3Wrapper, eventPollingIntervalMs);
+        this._balanceAndProxyAllowanceLazyStore = new BalanceAndProxyAllowanceLazyStore(token);
+        this._orderFilledCancelledLazyStore = new OrderFilledCancelledLazyStore(exchange);
+        this._orderStateUtils = new OrderStateUtils(
+            this._balanceAndProxyAllowanceLazyStore, this._orderFilledCancelledLazyStore,
+        );
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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];
+        this.removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, 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._callbackIfExistsAsync)) {
+            throw new Error(ZeroExError.SubscriptionAlreadyPresent);
+        }
+        this._callbackIfExistsAsync = callback;
+        this._eventWatcher.subscribe(this._onEventWatcherCallbackAsync.bind(this));
+    }
+    /**
+     * Ends an orderStateWatcher subscription.
+     */
+    public unsubscribe(): void {
+        if (_.isUndefined(this._callbackIfExistsAsync)) {
+            throw new Error(ZeroExError.SubscriptionNotFound);
+        }
+        this._balanceAndProxyAllowanceLazyStore.deleteAll();
+        this._orderFilledCancelledLazyStore.deleteAll();
+        delete this._callbackIfExistsAsync;
+        this._eventWatcher.unsubscribe();
+    }
+    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 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] as SignedOrder;
+            // Most of these calls will never reach the network because the data is fetched from stores
+            // and only updated when cache is invalidated
+            const orderState = await this._orderStateUtils.getOrderStateAsync(signedOrder);
+            if (_.isUndefined(this._callbackIfExistsAsync)) {
+                break; // Unsubscribe was called
+            }
+            await this._callbackIfExistsAsync(orderState);
+        }
+    }
+    private addToDependentOrderHashes(signedOrder: SignedOrder, orderHash: string) {
+        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);
+    }
+    private removeFromDependentOrderHashes(makerAddress: string, makerTokenAddress: string, orderHash: string) {
+        this._dependentOrderHashes[makerAddress][makerTokenAddress].delete(orderHash);
+        if (this._dependentOrderHashes[makerAddress][makerTokenAddress].size === 0) {
+            delete this._dependentOrderHashes[makerAddress][makerTokenAddress];
+        }
+        if (_.isEmpty(this._dependentOrderHashes[makerAddress])) {
+            delete this._dependentOrderHashes[makerAddress];
+        }
+    }
+}

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

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

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

@@ -0,0 +1,82 @@
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import {BigNumber} from 'bignumber.js';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {BlockParamLiteral} from '../types';
+
+/**
+ * Copy on read store for balances/proxyAllowances of tokens/accounts
+ */
+export class BalanceAndProxyAllowanceLazyStore {
+    private token: TokenWrapper;
+    private balance: {
+        [tokenAddress: string]: {
+            [userAddress: string]: BigNumber,
+        },
+    };
+    private proxyAllowance: {
+        [tokenAddress: string]: {
+            [userAddress: string]: BigNumber,
+        },
+    };
+    constructor(token: TokenWrapper) {
+        this.token = token;
+        this.balance = {};
+        this.proxyAllowance = {};
+    }
+    public async getBalanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
+        if (_.isUndefined(this.balance[tokenAddress]) || _.isUndefined(this.balance[tokenAddress][userAddress])) {
+            const methodOpts = {
+                defaultBlock: BlockParamLiteral.Pending,
+            };
+            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: BlockParamLiteral.Pending,
+            };
+            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

@@ -0,0 +1,61 @@
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import {BigNumber} from 'bignumber.js';
+import {ExchangeWrapper} from '../contract_wrappers/exchange_wrapper';
+import {BlockParamLiteral} from '../types';
+
+/**
+ * Copy on read store for filled/cancelled taker amounts
+ */
+export class OrderFilledCancelledLazyStore {
+    private exchange: ExchangeWrapper;
+    private filledTakerAmount: {
+        [orderHash: string]: BigNumber,
+    };
+    private 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,4 +1,5 @@
 import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
 
 export enum ZeroExError {
     ContractDoesNotExist = 'CONTRACT_DOES_NOT_EXIST',
@@ -15,6 +16,8 @@ export enum ZeroExError {
     OutOfGas = 'OUT_OF_GAS',
     NoNetworkId = 'NO_NETWORK_ID',
     SubscriptionNotFound = 'SUBSCRIPTION_NOT_FOUND',
+    SubscriptionAlreadyPresent = 'SUBSCRIPTION_ALREADY_PRESENT',
+    TransactionMiningTimeout = 'TRANSACTION_MINING_TIMEOUT',
 }
 
 export enum InternalZeroExError {
@@ -33,15 +36,20 @@ export interface ECSignature {
 
 export type OrderAddresses = [string, string, string, string, string];
 
-export type OrderValues = [BigNumber.BigNumber, BigNumber.BigNumber, BigNumber.BigNumber,
-                           BigNumber.BigNumber, BigNumber.BigNumber, BigNumber.BigNumber];
+export type OrderValues = [BigNumber, BigNumber, BigNumber,
+                           BigNumber, BigNumber, BigNumber];
 
-export interface LogEvent<ArgsType> extends LogWithDecodedArgs<ArgsType> {
-    removed: boolean;
-}
-export type EventCallbackAsync<ArgsType> = (log: LogEvent<ArgsType>) => Promise<void>;
-export type EventCallbackSync<ArgsType> = (log: LogEvent<ArgsType>) => void;
+export type LogEvent = Web3.LogEntryEvent;
+export type DecodedLogEvent<ArgsType> = Web3.DecodedLogEntryEvent<ArgsType>;
+
+export type EventCallbackAsync<ArgsType> = (err: null|Error, log?: DecodedLogEvent<ArgsType>) => Promise<void>;
+export type EventCallbackSync<ArgsType> = (err: null|Error, log?: DecodedLogEvent<ArgsType>) => void;
 export type EventCallback<ArgsType> = EventCallbackSync<ArgsType>|EventCallbackAsync<ArgsType>;
+
+export type EventWatcherCallbackSync = (log: LogEvent) => void;
+export type EventWatcherCallbackAsync = (log: LogEvent) => Promise<void>;
+export type EventWatcherCallback = EventWatcherCallbackSync|EventWatcherCallbackAsync;
+
 export interface ExchangeContract extends Web3.ContractInstance {
     isValidSignature: {
         callAsync: (signerAddressHex: string, dataHex: string, v: number, r: string, s: string,
@@ -54,77 +62,77 @@ export interface ExchangeContract extends Web3.ContractInstance {
         callAsync: () => Promise<string>;
     };
     getUnavailableTakerTokenAmount: {
-        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
     };
     isRoundingError: {
-        callAsync: (takerTokenFillAmount: BigNumber.BigNumber, takerTokenAmount: BigNumber.BigNumber,
-                    makerTokenAmount: BigNumber.BigNumber, txOpts?: TxOpts) => Promise<boolean>;
+        callAsync: (takerTokenFillAmount: BigNumber, takerTokenAmount: BigNumber,
+                    makerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise<boolean>;
     };
     fillOrder: {
         sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                               fillTakerTokenAmount: BigNumber.BigNumber,
+                               fillTakerTokenAmount: BigNumber,
                                shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                                v: number, r: string, s: string, txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                           fillTakerTokenAmount: BigNumber.BigNumber,
+                           fillTakerTokenAmount: BigNumber,
                            shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                            v: number, r: string, s: string, txOpts?: TxOpts) => Promise<number>;
     };
     batchFillOrders: {
         sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                               fillTakerTokenAmounts: BigNumber.BigNumber[],
+                               fillTakerTokenAmounts: BigNumber[],
                                shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                                v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                           fillTakerTokenAmounts: BigNumber.BigNumber[],
+                           fillTakerTokenAmounts: BigNumber[],
                            shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                            v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
     };
     fillOrdersUpTo: {
         sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                               fillTakerTokenAmount: BigNumber.BigNumber,
+                               fillTakerTokenAmount: BigNumber,
                                shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                                v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                           fillTakerTokenAmount: BigNumber.BigNumber,
+                           fillTakerTokenAmount: BigNumber,
                            shouldThrowOnInsufficientBalanceOrAllowance: boolean,
                            v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
     };
     cancelOrder: {
         sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                               cancelTakerTokenAmount: BigNumber.BigNumber, txOpts?: TxOpts) => Promise<string>;
+                               cancelTakerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                           cancelTakerTokenAmount: BigNumber.BigNumber,
+                           cancelTakerTokenAmount: BigNumber,
                            txOpts?: TxOpts) => Promise<number>;
     };
     batchCancelOrders: {
         sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                               cancelTakerTokenAmounts: BigNumber.BigNumber[], txOpts?: TxOpts) => Promise<string>;
+                               cancelTakerTokenAmounts: BigNumber[], txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                           cancelTakerTokenAmounts: BigNumber.BigNumber[],
+                           cancelTakerTokenAmounts: BigNumber[],
                            txOpts?: TxOpts) => Promise<number>;
     };
     fillOrKillOrder: {
         sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                               fillTakerTokenAmount: BigNumber.BigNumber,
+                               fillTakerTokenAmount: BigNumber,
                                v: number, r: string, s: string, txOpts?: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues,
-                           fillTakerTokenAmount: BigNumber.BigNumber,
+                           fillTakerTokenAmount: BigNumber,
                            v: number, r: string, s: string, txOpts?: TxOpts) => Promise<number>;
     };
     batchFillOrKillOrders: {
         sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                               fillTakerTokenAmounts: BigNumber.BigNumber[],
+                               fillTakerTokenAmounts: BigNumber[],
                                v: number[], r: string[], s: string[], txOpts: TxOpts) => Promise<string>;
         estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[],
-                           fillTakerTokenAmounts: BigNumber.BigNumber[],
+                           fillTakerTokenAmounts: BigNumber[],
                            v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise<number>;
     };
     filled: {
-        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
     };
     cancelled: {
-        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
+        callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
     };
     getOrderHash: {
         callAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues) => Promise<string>;
@@ -133,22 +141,22 @@ export interface ExchangeContract extends Web3.ContractInstance {
 
 export interface TokenContract extends Web3.ContractInstance {
     balanceOf: {
-        callAsync: (address: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
+        callAsync: (address: string, defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
     };
     allowance: {
         callAsync: (ownerAddress: string, allowedAddress: string,
-                    defaultBlock?: Web3.BlockParam) => Promise<BigNumber.BigNumber>;
+                    defaultBlock?: Web3.BlockParam) => Promise<BigNumber>;
     };
     transfer: {
-        sendTransactionAsync: (toAddress: string, amountInBaseUnits: BigNumber.BigNumber,
+        sendTransactionAsync: (toAddress: string, amountInBaseUnits: BigNumber,
                                txOpts?: TxOpts) => Promise<string>;
     };
     transferFrom: {
-        sendTransactionAsync: (fromAddress: string, toAddress: string, amountInBaseUnits: BigNumber.BigNumber,
+        sendTransactionAsync: (fromAddress: string, toAddress: string, amountInBaseUnits: BigNumber,
                                txOpts?: TxOpts) => Promise<string>;
     };
     approve: {
-        sendTransactionAsync: (proxyAddress: string, amountInBaseUnits: BigNumber.BigNumber,
+        sendTransactionAsync: (proxyAddress: string, amountInBaseUnits: BigNumber,
                                txOpts?: TxOpts) => Promise<string>;
     };
 }
@@ -179,7 +187,7 @@ export interface EtherTokenContract extends Web3.ContractInstance {
         sendTransactionAsync: (txOpts: TxOpts) => Promise<string>;
     };
     withdraw: {
-        sendTransactionAsync: (amount: BigNumber.BigNumber, txOpts: TxOpts) => Promise<string>;
+        sendTransactionAsync: (amount: BigNumber, txOpts: TxOpts) => Promise<string>;
     };
 }
 
@@ -253,10 +261,10 @@ export interface LogFillContractEventArgs {
     feeRecipient: string;
     makerToken: string;
     takerToken: string;
-    filledMakerTokenAmount: BigNumber.BigNumber;
-    filledTakerTokenAmount: BigNumber.BigNumber;
-    paidMakerFee: BigNumber.BigNumber;
-    paidTakerFee: BigNumber.BigNumber;
+    filledMakerTokenAmount: BigNumber;
+    filledTakerTokenAmount: BigNumber;
+    paidMakerFee: BigNumber;
+    paidTakerFee: BigNumber;
     tokens: string;
     orderHash: string;
 }
@@ -265,43 +273,43 @@ export interface LogCancelContractEventArgs {
     feeRecipient: string;
     makerToken: string;
     takerToken: string;
-    cancelledMakerTokenAmount: BigNumber.BigNumber;
-    cancelledTakerTokenAmount: BigNumber.BigNumber;
+    cancelledMakerTokenAmount: BigNumber;
+    cancelledTakerTokenAmount: BigNumber;
     tokens: string;
     orderHash: string;
 }
 export interface LogErrorContractEventArgs {
-    errorId: BigNumber.BigNumber;
+    errorId: BigNumber;
     orderHash: string;
 }
 export type ExchangeContractEventArgs = LogFillContractEventArgs|LogCancelContractEventArgs|LogErrorContractEventArgs;
 export interface TransferContractEventArgs {
     _from: string;
     _to: string;
-    _value: BigNumber.BigNumber;
+    _value: BigNumber;
 }
 export interface ApprovalContractEventArgs {
     _owner: string;
     _spender: string;
-    _value: BigNumber.BigNumber;
+    _value: BigNumber;
 }
 export type TokenContractEventArgs = TransferContractEventArgs|ApprovalContractEventArgs;
 export type ContractEventArgs = ExchangeContractEventArgs|TokenContractEventArgs;
-export type ContractEventArg = string|BigNumber.BigNumber;
+export type ContractEventArg = string|BigNumber;
 
 export interface Order {
     maker: string;
     taker: string;
-    makerFee: BigNumber.BigNumber;
-    takerFee: BigNumber.BigNumber;
-    makerTokenAmount: BigNumber.BigNumber;
-    takerTokenAmount: BigNumber.BigNumber;
+    makerFee: BigNumber;
+    takerFee: BigNumber;
+    makerTokenAmount: BigNumber;
+    takerTokenAmount: BigNumber;
     makerTokenAddress: string;
     takerTokenAddress: string;
-    salt: BigNumber.BigNumber;
+    salt: BigNumber;
     exchangeContractAddress: string;
     feeRecipient: string;
-    expirationUnixTimestampSec: BigNumber.BigNumber;
+    expirationUnixTimestampSec: BigNumber;
 }
 
 export interface SignedOrder extends Order {
@@ -309,7 +317,7 @@ export interface SignedOrder extends Order {
 }
 
 //                          [address, name, symbol, decimals, ipfsHash, swarmHash]
-export type TokenMetadata = [string, string, string, BigNumber.BigNumber, string, string];
+export type TokenMetadata = [string, string, string, BigNumber, string, string];
 
 export interface Token {
     name: string;
@@ -321,7 +329,7 @@ export interface Token {
 export interface TxOpts {
     from: string;
     gas?: number;
-    value?: BigNumber.BigNumber;
+    value?: BigNumber;
 }
 
 export interface TokenAddressBySymbol {
@@ -362,12 +370,12 @@ export type DoneCallback = (err?: Error) => void;
 
 export interface OrderCancellationRequest {
     order: Order|SignedOrder;
-    takerTokenCancelAmount: BigNumber.BigNumber;
+    takerTokenCancelAmount: BigNumber;
 }
 
 export interface OrderFillRequest {
     signedOrder: SignedOrder;
-    takerTokenFillAmount: BigNumber.BigNumber;
+    takerTokenFillAmount: BigNumber;
 }
 
 export type AsyncMethod = (...args: any[]) => Promise<any>;
@@ -388,21 +396,28 @@ export interface JSONRPCPayload {
     method: string;
 }
 
+/*
+ * eventPollingIntervalMs: How often to poll the Ethereum node for new events
+ */
+export interface OrderStateWatcherConfig {
+    eventPollingIntervalMs?: number;
+}
+
 /*
  * 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
  * etherTokenContractAddress: The address of an ether token contract to use
+ * orderWatcherConfig: All the configs related to the orderWatcher
  */
 export interface ZeroExConfig {
-    gasPrice?: BigNumber.BigNumber; // Gas price to use with every transaction
+    gasPrice?: BigNumber; // Gas price to use with every transaction
     exchangeContractAddress?: string;
     tokenRegistryContractAddress?: string;
     etherTokenContractAddress?: string;
+    orderWatcherConfig?: OrderStateWatcherConfig;
 }
 
-export type TransactionReceipt = Web3.TransactionReceipt;
-
 export enum AbiType {
     Function = 'function',
     Constructor = 'constructor',
@@ -414,14 +429,9 @@ export interface DecodedLogArgs {
     [argName: string]: ContractEventArg;
 }
 
-export interface DecodedArgs<ArgsType> {
-    args: ArgsType;
-    event: string;
-}
+export interface LogWithDecodedArgs<ArgsType> extends Web3.DecodedLogEntry<ArgsType> {}
 
-export interface LogWithDecodedArgs<ArgsType> extends Web3.LogEntry, DecodedArgs<ArgsType> {}
-
-export interface TransactionReceiptWithDecodedLogs extends Web3.TransactionReceipt {
+export interface TransactionReceiptWithDecodedLogs extends TransactionReceipt {
     logs: Array<LogWithDecodedArgs<DecodedLogArgs>|Web3.LogEntry>;
 }
 
@@ -439,7 +449,7 @@ export interface Artifact {
  * allowance/balance to fill the entire remaining order amount.
  */
 export interface ValidateOrderFillableOpts {
-    expectedFillTakerTokenAmount?: BigNumber.BigNumber;
+    expectedFillTakerTokenAmount?: BigNumber;
 }
 
 /*
@@ -471,3 +481,45 @@ export enum TransferType {
     Trade = 'trade',
     Fee = 'fee',
 }
+
+export interface OrderRelevantState {
+    makerBalance: BigNumber;
+    makerProxyAllowance: BigNumber;
+    makerFeeBalance: BigNumber;
+    makerFeeProxyAllowance: BigNumber;
+    filledTakerTokenAmount: BigNumber;
+    cancelledTakerTokenAmount: BigNumber;
+    remainingFillableMakerTokenAmount: 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 OnOrderStateChangeCallbackSync = (orderState: OrderState) => void;
+export type OnOrderStateChangeCallbackAsync = (orderState: OrderState) => Promise<void>;
+export type OnOrderStateChangeCallback = OnOrderStateChangeCallbackAsync|OnOrderStateChangeCallbackSync;
+
+export interface TransactionReceipt {
+    blockHash: string;
+    blockNumber: number;
+    transactionHash: string;
+    transactionIndex: number;
+    from: string;
+    to: string;
+    status: null|0|1;
+    cumulativeGasUsed: number;
+    gasUsed: number;
+    contractAddress: string|null;
+    logs: Web3.LogEntry[];
+}

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

@@ -1,6 +1,6 @@
 import * as Web3 from 'web3';
 import * as _ from 'lodash';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {AbiType, DecodedLogArgs, LogWithDecodedArgs, RawLog, SolidityTypes, ContractEventArgs} from '../types';
 import * as SolidityCoder from 'web3/lib/solidity/coder';
 
@@ -10,7 +10,7 @@ export class AbiDecoder {
     constructor(abiArrays: Web3.AbiDefinition[][]) {
         _.map(abiArrays, this.addABI.bind(this));
     }
-    // This method can only decode logs from the 0x smart contracts
+    // 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];
@@ -34,7 +34,7 @@ export class AbiDecoder {
                 value = this.padZeros(new BigNumber(value).toString(16));
             } else if (param.type === SolidityTypes.Uint256 ||
                        param.type === SolidityTypes.Uint8 ||
-                       param.type === SolidityTypes.Uint ) {
+                       param.type === SolidityTypes.Uint) {
                 value = new BigNumber(value);
             }
             decodedParams[param.name] = value;

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

@@ -0,0 +1,29 @@
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import {SchemaValidator, Schema} from '@0xproject/json-schemas';
+import {assert as sharedAssert} from '@0xproject/assert';
+import {Web3Wrapper} from '../web3_wrapper';
+import {signatureUtils} from '../utils/signature_utils';
+import {ECSignature} from '../types';
+
+const HEX_REGEX = /^0x[0-9A-F]*$/i;
+
+export const assert = _.extend({}, 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/constants.ts

@@ -1,4 +1,4 @@
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',

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

@@ -0,0 +1,88 @@
+import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import {ExchangeContractErrs, TradeSide, TransferType, BlockParamLiteral} from '../types';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
+
+enum FailureReason {
+    Balance = 'balance',
+    ProxyAllowance = 'proxyAllowance',
+}
+
+const ERR_MSG_MAPPING = {
+    [FailureReason.Balance]: {
+        [TradeSide.Maker]: {
+            [TransferType.Trade]: ExchangeContractErrs.InsufficientMakerBalance,
+            [TransferType.Fee]: ExchangeContractErrs.InsufficientMakerFeeBalance,
+        },
+        [TradeSide.Taker]: {
+            [TransferType.Trade]: ExchangeContractErrs.InsufficientTakerBalance,
+            [TransferType.Fee]: ExchangeContractErrs.InsufficientTakerFeeBalance,
+        },
+    },
+    [FailureReason.ProxyAllowance]: {
+        [TradeSide.Maker]: {
+            [TransferType.Trade]: ExchangeContractErrs.InsufficientMakerAllowance,
+            [TransferType.Fee]: ExchangeContractErrs.InsufficientMakerFeeAllowance,
+        },
+        [TradeSide.Taker]: {
+            [TransferType.Trade]: ExchangeContractErrs.InsufficientTakerAllowance,
+            [TransferType.Fee]: ExchangeContractErrs.InsufficientTakerFeeAllowance,
+        },
+    },
+};
+
+export class ExchangeTransferSimulator {
+    private store: BalanceAndProxyAllowanceLazyStore;
+    private UNLIMITED_ALLOWANCE_IN_BASE_UNITS: BigNumber;
+    constructor(token: TokenWrapper) {
+        this.store = new BalanceAndProxyAllowanceLazyStore(token);
+        this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS = token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+    }
+    /**
+     * Simulates transferFrom call performed by a proxy
+     * @param  tokenAddress      Address of the token to be transferred
+     * @param  from              Owner of the transferred tokens
+     * @param  to                Recipient of the transferred tokens
+     * @param  amountInBaseUnits The amount of tokens being transferred
+     * @param  tradeSide         Is Maker/Taker transferring
+     * @param  transferType      Is it a fee payment or a value transfer
+     */
+    public async transferFromAsync(tokenAddress: string, from: string, to: string,
+                                   amountInBaseUnits: BigNumber, tradeSide: TradeSide,
+                                   transferType: TransferType): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, from);
+        const proxyAllowance = await this.store.getProxyAllowanceAsync(tokenAddress, from);
+        if (proxyAllowance.lessThan(amountInBaseUnits)) {
+            this.throwValidationError(FailureReason.ProxyAllowance, tradeSide, transferType);
+        }
+        if (balance.lessThan(amountInBaseUnits)) {
+            this.throwValidationError(FailureReason.Balance, tradeSide, transferType);
+        }
+        await this.decreaseProxyAllowanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this.decreaseBalanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this.increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
+    }
+    private async decreaseProxyAllowanceAsync(tokenAddress: string, userAddress: string,
+                                              amountInBaseUnits: BigNumber): Promise<void> {
+        const proxyAllowance = await this.store.getProxyAllowanceAsync(tokenAddress, userAddress);
+        if (!proxyAllowance.eq(this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS)) {
+            this.store.setProxyAllowance(tokenAddress, userAddress, proxyAllowance.minus(amountInBaseUnits));
+        }
+    }
+    private async increaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                       amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
+        this.store.setBalance(tokenAddress, userAddress, balance.plus(amountInBaseUnits));
+    }
+    private async decreaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                       amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
+        this.store.setBalance(tokenAddress, userAddress, balance.minus(amountInBaseUnits));
+    }
+    private throwValidationError(failureReason: FailureReason, tradeSide: TradeSide,
+                                 transferType: TransferType): Promise<never> {
+        const errMsg = ERR_MSG_MAPPING[failureReason][tradeSide][transferType];
+        throw new Error(errMsg);
+    }
+}

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

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

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

@@ -1,4 +1,5 @@
 import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
 import {ExchangeContractErrs, SignedOrder, Order, ZeroExError, TradeSide, TransferType} from '../types';
 import {ZeroEx} from '../0x';
 import {TokenWrapper} from '../contract_wrappers/token_wrapper';
@@ -16,7 +17,7 @@ export class OrderValidationUtils {
     }
     public async validateOrderFillableOrThrowAsync(
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder, zrxTokenAddress: string,
-        expectedFillTakerTokenAmount?: BigNumber.BigNumber): Promise<void> {
+        expectedFillTakerTokenAmount?: BigNumber): Promise<void> {
         const orderHash = utils.getOrderHashHex(signedOrder);
         const unavailableTakerTokenAmount = await this.exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
         this.validateRemainingFillAmountNotZeroOrThrow(
@@ -48,8 +49,8 @@ export class OrderValidationUtils {
     }
     public async validateFillOrderThrowIfInvalidAsync(
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber.BigNumber, takerAddress: string,
-        zrxTokenAddress: string): Promise<BigNumber.BigNumber> {
+        fillTakerTokenAmount: BigNumber, takerAddress: string,
+        zrxTokenAddress: string): Promise<BigNumber> {
         if (fillTakerTokenAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.OrderFillAmountZero);
         }
@@ -83,7 +84,7 @@ export class OrderValidationUtils {
     }
     public async validateFillOrKillOrderThrowIfInvalidAsync(
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber.BigNumber, takerAddress: string, zrxTokenAddress: string): Promise<void> {
+        fillTakerTokenAmount: BigNumber, takerAddress: string, zrxTokenAddress: string): Promise<void> {
         const filledTakerTokenAmount = await this.validateFillOrderThrowIfInvalidAsync(
             exchangeTradeEmulator, signedOrder, fillTakerTokenAmount, takerAddress, zrxTokenAddress,
         );
@@ -92,8 +93,8 @@ export class OrderValidationUtils {
         }
     }
     public async validateCancelOrderThrowIfInvalidAsync(order: Order,
-                                                        cancelTakerTokenAmount: BigNumber.BigNumber,
-                                                        unavailableTakerTokenAmount: BigNumber.BigNumber,
+                                                        cancelTakerTokenAmount: BigNumber,
+                                                        unavailableTakerTokenAmount: BigNumber,
     ): Promise<void> {
         if (cancelTakerTokenAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.OrderCancelAmountZero);
@@ -108,7 +109,7 @@ export class OrderValidationUtils {
     }
     public async validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
-        fillTakerTokenAmount: BigNumber.BigNumber, senderAddress: string, zrxTokenAddress: string): Promise<void> {
+        fillTakerTokenAmount: BigNumber, senderAddress: string, zrxTokenAddress: string): Promise<void> {
         const fillMakerTokenAmount = this.getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
@@ -142,20 +143,20 @@ export class OrderValidationUtils {
         );
     }
     private validateRemainingFillAmountNotZeroOrThrow(
-        takerTokenAmount: BigNumber.BigNumber, unavailableTakerTokenAmount: BigNumber.BigNumber,
+        takerTokenAmount: BigNumber, unavailableTakerTokenAmount: BigNumber,
     ) {
         if (takerTokenAmount.eq(unavailableTakerTokenAmount)) {
             throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
         }
     }
-    private validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber.BigNumber) {
+    private validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
         const currentUnixTimestampSec = utils.getCurrentUnixTimestamp();
         if (expirationUnixTimestampSec.lessThan(currentUnixTimestampSec)) {
             throw new Error(ExchangeContractErrs.OrderFillExpired);
         }
     }
-    private getPartialAmount(numerator: BigNumber.BigNumber, denominator: BigNumber.BigNumber,
-                             target: BigNumber.BigNumber): BigNumber.BigNumber {
+    private getPartialAmount(numerator: BigNumber, denominator: BigNumber,
+                             target: BigNumber): BigNumber {
         const fillMakerTokenAmount = numerator
                                      .mul(target)
                                      .div(denominator)

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

@@ -2,6 +2,21 @@ 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];

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

@@ -2,7 +2,7 @@ import * as _ from 'lodash';
 import * as ethABI from 'ethereumjs-abi';
 import * as ethUtil from 'ethereumjs-util';
 import {Order, SignedOrder, SolidityTypes} from '../types';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import BN = require('bn.js');
 
 export const utils = {
@@ -12,7 +12,7 @@ export const utils = {
      * 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.BigNumber) {
+    bigNumberToBN(value: BigNumber) {
         return new BN(value.toString(), 10);
     },
     consoleLog(message: string): void {
@@ -49,7 +49,7 @@ export const utils = {
         const hashHex = ethUtil.bufferToHex(hashBuff);
         return hashHex;
     },
-    getCurrentUnixTimestamp(): BigNumber.BigNumber {
+    getCurrentUnixTimestamp(): BigNumber {
         return new BigNumber(Date.now() / 1000);
     },
 };

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

@@ -1,8 +1,8 @@
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import promisify = require('es6-promisify');
-import {ZeroExError, Artifact} from './types';
+import {ZeroExError, Artifact, TransactionReceipt} from './types';
 import {Contract} from './contract';
 
 export class Web3Wrapper {
@@ -10,10 +10,16 @@ export class Web3Wrapper {
     private defaults: Partial<Web3.TxData>;
     private networkIdIfExists?: number;
     private jsonRpcRequestId: number;
-    constructor(provider: Web3.Provider, defaults: Partial<Web3.TxData>) {
+    constructor(provider: Web3.Provider, defaults?: Partial<Web3.TxData>) {
+        if (_.isUndefined((provider as any).sendAsync)) {
+            // Web3@1.0 provider doesn't support synchronous http requests,
+            // so it only has an async `send` method, instead of a `send` and `sendAsync` in web3@0.x.x`
+            // We re-assign the send method so that Web3@1.0 providers work with 0x.js
+            (provider as any).sendAsync = (provider as any).send;
+        }
         this.web3 = new Web3();
         this.web3.setProvider(provider);
-        this.defaults = defaults;
+        this.defaults = defaults || {};
         this.jsonRpcRequestId = 0;
     }
     public setProvider(provider: Web3.Provider) {
@@ -31,8 +37,9 @@ export class Web3Wrapper {
         const nodeVersion = await promisify(this.web3.version.getNode)();
         return nodeVersion;
     }
-    public async getTransactionReceiptAsync(txHash: string): Promise<Web3.TransactionReceipt> {
+    public async getTransactionReceiptAsync(txHash: string): Promise<TransactionReceipt> {
         const transactionReceipt = await promisify(this.web3.eth.getTransactionReceipt)(txHash);
+        transactionReceipt.status = this.normalizeTxReceiptStatus(transactionReceipt.status);
         return transactionReceipt;
     }
     public getCurrentProvider(): Web3.Provider {
@@ -75,11 +82,11 @@ export class Web3Wrapper {
         );
         return contractInstance;
     }
-    public toWei(ethAmount: BigNumber.BigNumber): BigNumber.BigNumber {
+    public toWei(ethAmount: BigNumber): BigNumber {
         const balanceWei = this.web3.toWei(ethAmount, 'ether');
         return balanceWei;
     }
-    public async getBalanceInWeiAsync(owner: string): Promise<BigNumber.BigNumber> {
+    public async getBalanceInWeiAsync(owner: string): Promise<BigNumber> {
         let balanceInWei = await promisify(this.web3.eth.getBalance)(owner);
         balanceInWei = new BigNumber(balanceInWei);
         return balanceInWei;
@@ -94,6 +101,10 @@ export class Web3Wrapper {
         const signData = await promisify(this.web3.eth.sign)(address, message);
         return signData;
     }
+    public async getBlockNumberAsync(): Promise<number> {
+        const blockNumber = await promisify(this.web3.eth.getBlockNumber)();
+        return blockNumber;
+    }
     public async getBlockAsync(blockParam: string|Web3.BlockParam): Promise<Web3.BlockWithoutTransactionData> {
         const block = await promisify(this.web3.eth.getBlock)(blockParam);
         return block;
@@ -144,4 +155,18 @@ export class Web3Wrapper {
         const result = response.result;
         return result;
     }
+    private normalizeTxReceiptStatus(status: undefined|null|string|0|1): null|0|1 {
+        // Transaction status might have four values
+        // undefined - Testrpc and other old clients
+        // null - New clients on old transactions
+        // number - Parity
+        // hex - Geth
+        if (_.isString(status)) {
+            return this.web3.toDecimal(status) as 0|1;
+        } else if (_.isUndefined(status)) {
+            return null;
+        } else {
+            return status;
+        }
+    }
 }

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

@@ -2,7 +2,7 @@ import * as _ from 'lodash';
 import * as chai from 'chai';
 import {chaiSetup} from './utils/chai_setup';
 import 'mocha';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import * as Sinon from 'sinon';
 import {ZeroEx, Order, ZeroExError, LogWithDecodedArgs, ApprovalContractEventArgs, TokenEvents} from '../src';
 import {constants} from './utils/constants';

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

@@ -2,7 +2,7 @@ import 'mocha';
 import * as chai from 'chai';
 import {chaiSetup} from './utils/chai_setup';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {web3Factory} from './utils/web3_factory';
 import {ZeroEx, ZeroExError} from '../src';
 import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
@@ -23,7 +23,7 @@ describe('EtherTokenWrapper', () => {
     let userAddresses: string[];
     let addressWithETH: string;
     let wethContractAddress: string;
-    let depositWeiAmount: BigNumber.BigNumber;
+    let depositWeiAmount: BigNumber;
     let decimalPlaces: number;
     const gasPrice = new BigNumber(1);
     const zeroExConfig = {

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

@@ -0,0 +1,127 @@
+import 'mocha';
+import * as chai from 'chai';
+import * as _ from 'lodash';
+import * as Sinon from 'sinon';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {Web3Wrapper} from '../src/web3_wrapper';
+import {EventWatcher} from '../src/order_watcher/event_watcher';
+import {
+    ZeroEx,
+    LogEvent,
+    DecodedLogEvent,
+} from '../src';
+import {DoneCallback} from '../src/types';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('EventWatcher', () => {
+    let web3: Web3;
+    let stubs: Sinon.SinonStub[] = [];
+    let eventWatcher: EventWatcher;
+    let web3Wrapper: Web3Wrapper;
+    const numConfirmations = 0;
+    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,5 +1,5 @@
 import * as chai from 'chai';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {chaiSetup} from './utils/chai_setup';
 import {web3Factory} from './utils/web3_factory';
 import {ZeroEx, ExchangeContractErrs, Token} from '../src';
@@ -59,11 +59,10 @@ describe('ExchangeTransferSimulator', () => {
             await exchangeTransferSimulator.transferFromAsync(
                 exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Taker, TransferType.Trade,
             );
-            const senderBalance = await (exchangeTransferSimulator as any).getBalanceAsync(exampleTokenAddress, sender);
-            const recipientBalance = await (exchangeTransferSimulator as any).getBalanceAsync(
-                exampleTokenAddress, recipient);
-            const senderProxyAllowance = await (exchangeTransferSimulator as any).getProxyAllowanceAsync(
-                exampleTokenAddress, sender);
+            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);
@@ -76,11 +75,10 @@ describe('ExchangeTransferSimulator', () => {
             await exchangeTransferSimulator.transferFromAsync(
                 exampleTokenAddress, sender, recipient, transferAmount, TradeSide.Taker, TransferType.Trade,
             );
-            const senderBalance = await (exchangeTransferSimulator as any).getBalanceAsync(exampleTokenAddress, sender);
-            const recipientBalance = await (exchangeTransferSimulator as any).getBalanceAsync(
-                exampleTokenAddress, recipient);
-            const senderProxyAllowance = await (exchangeTransferSimulator as any).getProxyAllowanceAsync(
-                exampleTokenAddress, sender);
+            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/exchange_wrapper_test.ts

@@ -1,7 +1,7 @@
 import 'mocha';
 import * as chai from 'chai';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {chaiSetup} from './utils/chai_setup';
 import {web3Factory} from './utils/web3_factory';
 import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
@@ -11,13 +11,13 @@ import {
     SignedOrder,
     SubscriptionOpts,
     ExchangeEvents,
-    ContractEvent,
     ExchangeContractErrs,
     OrderCancellationRequest,
     OrderFillRequest,
     LogFillContractEventArgs,
     LogCancelContractEventArgs,
     LogEvent,
+    DecodedLogEvent,
 } from '../src';
 import {DoneCallback, BlockParamLiteral} from '../src/types';
 import {FillScenarios} from './utils/fill_scenarios';
@@ -70,7 +70,7 @@ describe('ExchangeWrapper', () => {
             takerTokenAddress = takerToken.address;
         });
         describe('#batchFillOrKillAsync', () => {
-            it('successfuly batch fillOrKill', async () => {
+            it('successfully batch fillOrKill', async () => {
                 const fillableAmount = new BigNumber(5);
                 const partialFillTakerAmount = new BigNumber(2);
                 const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
@@ -304,11 +304,11 @@ describe('ExchangeWrapper', () => {
                     orderFillBatch = [
                         {
                             signedOrder,
-                            takerTokenFillAmount: takerTokenFillAmount,
+                            takerTokenFillAmount,
                         },
                         {
                             signedOrder: anotherSignedOrder,
-                            takerTokenFillAmount: takerTokenFillAmount,
+                            takerTokenFillAmount,
                         },
                     ];
                 });
@@ -443,7 +443,7 @@ describe('ExchangeWrapper', () => {
                 it('should cancel an order', async () => {
                     const txHash = await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
                     await zeroEx.awaitTransactionMinedAsync(txHash);
-                    const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHashHex);
+                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
                     expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
                 });
             });
@@ -502,8 +502,8 @@ describe('ExchangeWrapper', () => {
             describe('successful batch cancels', () => {
                 it('should cancel a batch of orders', async () => {
                     await zeroEx.exchange.batchCancelOrdersAsync(cancelBatch);
-                    const cancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHashHex);
-                    const anotherCancelledAmount = await zeroEx.exchange.getCanceledTakerAmountAsync(
+                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
+                    const anotherCancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(
                         anotherOrderHashHex,
                     );
                     expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
@@ -545,8 +545,8 @@ describe('ExchangeWrapper', () => {
         let makerTokenAddress: string;
         let takerTokenAddress: string;
         let takerAddress: string;
-        let fillableAmount: BigNumber.BigNumber;
-        let partialFillAmount: BigNumber.BigNumber;
+        let fillableAmount: BigNumber;
+        let partialFillAmount: BigNumber;
         let signedOrder: SignedOrder;
         let orderHash: string;
         before(() => {
@@ -592,23 +592,23 @@ describe('ExchangeWrapper', () => {
                 expect(filledValueT).to.be.bignumber.equal(partialFillAmount);
             });
         });
-        describe('#getCanceledTakerAmountAsync', () => {
+        describe('#getCancelledTakerAmountAsync', () => {
             it('should throw if passed an invalid orderHash', async () => {
                 const invalidOrderHashHex = '0x123';
-                return expect(zeroEx.exchange.getCanceledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+                return expect(zeroEx.exchange.getCancelledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
             });
             it('should return zero if passed a valid but non-existent orderHash', async () => {
-                const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
                 expect(cancelledValueT).to.be.bignumber.equal(0);
             });
             it('should return the cancelledValueT for a valid and partially filled orderHash', async () => {
-                const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHash);
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
                 expect(cancelledValueT).to.be.bignumber.equal(0);
             });
             it('should return the cancelledValueT for a valid and cancelled orderHash', async () => {
                 const cancelAmount = fillableAmount.minus(partialFillAmount);
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
-                const cancelledValueT = await zeroEx.exchange.getCanceledTakerAmountAsync(orderHash);
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
                 expect(cancelledValueT).to.be.bignumber.equal(cancelAmount);
             });
         });
@@ -621,7 +621,7 @@ describe('ExchangeWrapper', () => {
         let coinbase: string;
         let takerAddress: string;
         let makerAddress: string;
-        let fillableAmount: BigNumber.BigNumber;
+        let fillableAmount: BigNumber;
         let signedOrder: SignedOrder;
         const takerTokenFillAmountInBaseUnits = new BigNumber(1);
         const cancelTakerAmountInBaseUnits = new BigNumber(1);
@@ -647,7 +647,8 @@ describe('ExchangeWrapper', () => {
         // Source: https://github.com/mochajs/mocha/issues/2407
         it('Should receive the LogFill event when an order is filled', (done: DoneCallback) => {
             (async () => {
-                const callback = (logEvent: LogEvent<LogFillContractEventArgs>) => {
+
+                const callback = (err: Error, logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                     expect(logEvent.event).to.be.equal(ExchangeEvents.LogFill);
                     done();
                 };
@@ -655,13 +656,15 @@ describe('ExchangeWrapper', () => {
                     ExchangeEvents.LogFill, indexFilterValues, callback,
                 );
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
                 );
             })().catch(done);
         });
         it('Should receive the LogCancel event when an order is cancelled', (done: DoneCallback) => {
             (async () => {
-                const callback = (logEvent: LogEvent<LogCancelContractEventArgs>) => {
+
+                const callback = (err: Error, logEvent: DecodedLogEvent<LogCancelContractEventArgs>) => {
                     expect(logEvent.event).to.be.equal(ExchangeEvents.LogCancel);
                     done();
                 };
@@ -673,7 +676,8 @@ describe('ExchangeWrapper', () => {
         });
         it('Outstanding subscriptions are cancelled when zeroEx.setProviderAsync called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = (logEvent: LogEvent<LogFillContractEventArgs>) => {
+
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                     done(new Error('Expected this subscription to have been cancelled'));
                 };
                 await zeroEx.exchange.subscribeAsync(
@@ -683,7 +687,7 @@ describe('ExchangeWrapper', () => {
                 const newProvider = web3Factory.getRpcProvider();
                 await zeroEx.setProviderAsync(newProvider);
 
-                const callback = (logEvent: LogEvent<LogFillContractEventArgs>) => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                     expect(logEvent.event).to.be.equal(ExchangeEvents.LogFill);
                     done();
                 };
@@ -691,13 +695,14 @@ describe('ExchangeWrapper', () => {
                     ExchangeEvents.LogFill, indexFilterValues, callback,
                 );
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
                 );
             })().catch(done);
         });
         it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = (logEvent: LogEvent<LogFillContractEventArgs>) => {
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
                     done(new Error('Expected this subscription to have been cancelled'));
                 };
                 const subscriptionToken = await zeroEx.exchange.subscribeAsync(
@@ -705,7 +710,8 @@ describe('ExchangeWrapper', () => {
                 );
                 zeroEx.exchange.unsubscribe(subscriptionToken);
                 await zeroEx.exchange.fillOrderAsync(
-                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    signedOrder, takerTokenFillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
                 );
                 done();
             })().catch(done);

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

@@ -0,0 +1,362 @@
+import 'mocha';
+import * as chai from 'chai';
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import { chaiSetup } from './utils/chai_setup';
+import { web3Factory } from './utils/web3_factory';
+import { Web3Wrapper } from '../src/web3_wrapper';
+import { OrderStateWatcher } from '../src/order_watcher/order_state_watcher';
+import {
+    Token,
+    ZeroEx,
+    LogEvent,
+    DecodedLogEvent,
+    ZeroExConfig,
+    OrderState,
+    SignedOrder,
+    ZeroExError,
+    OrderStateValid,
+    OrderStateInvalid,
+    ExchangeContractErrs,
+} from '../src';
+import { TokenUtils } from './utils/token_utils';
+import { FillScenarios } from './utils/fill_scenarios';
+import { DoneCallback } from '../src/types';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {reportCallbackErrors} from './utils/report_callback_errors';
+
+const TIMEOUT_MS = 150;
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle();
+
+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 web3Wrapper: Web3Wrapper;
+    let signedOrder: SignedOrder;
+    const fillableAmount = new BigNumber(5);
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        [, maker, taker] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
+        web3Wrapper = (zeroEx as any)._web3Wrapper;
+    });
+    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 = reportCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerAllowance);
+                    done();
+                });
+                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,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const callback = reportCallbackErrors(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);
+                const notTheMakerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, notTheMaker);
+                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 = reportCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerBalance);
+                    done();
+                });
+                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);
+
+                let eventCount = 0;
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    eventCount++;
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                    if (eventCount === 2) {
+                        done();
+                    }
+                });
+                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 takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+
+                const fillAmountInBaseUnits = new BigNumber(2);
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                let eventCount = 0;
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    eventCount++;
+                    expect(orderState.isValid).to.be.true();
+                    const validOrderState = orderState as OrderStateValid;
+                    expect(validOrderState.orderHash).to.be.equal(orderHash);
+                    const orderRelevantState = validOrderState.orderRelevantState;
+                    const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
+                    const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
+                    expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                        remainingFillable);
+                    expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
+                    if (eventCount === 2) {
+                        done();
+                    }
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                const shouldThrowOnInsufficientBalanceOrAllowance = true;
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, taker,
+                );
+            })().catch(done);
+        });
+        describe('remainingFillableMakerTokenAmount', () => {
+          it('should calculate correct remaining fillable', (done: DoneCallback) => {
+              (async () => {
+                  const takerFillableAmount = new BigNumber(10);
+                  const makerFillableAmount = new BigNumber(20);
+                  signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                      makerToken.address, takerToken.address, maker, taker, makerFillableAmount, takerFillableAmount);
+                  const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                  const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+                  const fillAmountInBaseUnits = new BigNumber(2);
+                  const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                  zeroEx.orderStateWatcher.addOrder(signedOrder);
+                  let eventCount = 0;
+                  const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                      eventCount++;
+                      expect(orderState.isValid).to.be.true();
+                      const validOrderState = orderState as OrderStateValid;
+                      expect(validOrderState.orderHash).to.be.equal(orderHash);
+                      const orderRelevantState = validOrderState.orderRelevantState;
+                      expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                          new BigNumber(16));
+                      if (eventCount === 2) {
+                          done();
+                      }
+                  });
+                  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 makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+
+                  const changedMakerApprovalAmount = new BigNumber(3);
+                  zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                  const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                      const validOrderState = orderState as OrderStateValid;
+                      const orderRelevantState = validOrderState.orderRelevantState;
+                      expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                          changedMakerApprovalAmount);
+                      done();
+                  });
+                  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 = new BigNumber(1);
+                  const transferAmount = makerBalance.sub(remainingAmount);
+                  zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                  const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                      const validOrderState = orderState as OrderStateValid;
+                      const orderRelevantState = validOrderState.orderRelevantState;
+                      expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                          remainingAmount);
+                      done();
+                  });
+                  zeroEx.orderStateWatcher.subscribe(callback);
+                  await zeroEx.token.transferAsync(
+                      makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
+              })().catch(done);
+          });
+        });
+        it('should emit orderStateInvalid when watched order cancelled', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                    done();
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+
+                const shouldThrowOnInsufficientBalanceOrAllowance = true;
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            })().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 makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+
+                const cancelAmountInBaseUnits = new BigNumber(2);
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.true();
+                    const validOrderState = orderState as OrderStateValid;
+                    expect(validOrderState.orderHash).to.be.equal(orderHash);
+                    const orderRelevantState = validOrderState.orderRelevantState;
+                    expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
+                    done();
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
+            })().catch(done);
+        });
+    });
+});

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

@@ -1,6 +1,6 @@
 import * as chai from 'chai';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import * as Sinon from 'sinon';
 import {chaiSetup} from './utils/chai_setup';
 import {web3Factory} from './utils/web3_factory';
@@ -211,8 +211,8 @@ describe('OrderValidation', () => {
     describe('#validateFillOrderBalancesAllowancesThrowIfInvalidAsync', () => {
         let exchangeTransferSimulator: ExchangeTransferSimulator;
         let transferFromAsync: Sinon.SinonSpy;
-        const bigNumberMatch = (expected: BigNumber.BigNumber) => {
-            return Sinon.match((value: BigNumber.BigNumber) => value.eq(expected));
+        const bigNumberMatch = (expected: BigNumber) => {
+            return Sinon.match((value: BigNumber) => value.eq(expected));
         };
         beforeEach('create exchangeTransferSimulator', async () => {
             exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token);

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

@@ -0,0 +1,95 @@
+import 'mocha';
+import * as _ from 'lodash';
+import * as chai from 'chai';
+import * as Sinon from 'sinon';
+import {chaiSetup} from './utils/chai_setup';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {web3Factory} from './utils/web3_factory';
+import {
+    ZeroEx,
+    ZeroExError,
+    Token,
+    ApprovalContractEventArgs,
+    TokenEvents,
+    DecodedLogEvent,
+} from '../src';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {TokenUtils} from './utils/token_utils';
+import {DoneCallback, BlockParamLiteral} from '../src/types';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle();
+
+describe('SubscriptionTest', () => {
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let userAddresses: string[];
+    let tokens: Token[];
+    let tokenUtils: TokenUtils;
+    let coinbase: string;
+    let addressWithoutFunds: string;
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        coinbase = userAddresses[0];
+        addressWithoutFunds = userAddresses[1];
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
+        let tokenAddress: string;
+        const transferAmount = new BigNumber(42);
+        const allowanceAmount = new BigNumber(42);
+        let stubs: Sinon.SinonStub[] = [];
+        before(() => {
+            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', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                    expect(err).to.not.be.null();
+                    expect(logEvent).to.be.undefined();
+                    done();
+                };
+                stubs = [
+                  Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync')
+                   .throws('JSON RPC error'),
+                ];
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+            })().catch(done);
+         });
+        it('Should allow unsubscribeAll to be called successfully after an error', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
+                zeroEx.token.subscribe(
+                    tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                stubs = [
+                  Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync')
+                   .throws('JSON RPC error'),
+                ];
+                zeroEx.token.unsubscribeAll();
+                done();
+            })().catch(done);
+         });
+    });
+});

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

@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
 import 'mocha';
 import * as chai from 'chai';
-import {SchemaValidator, schemas} from '0x-json-schemas';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
 import {chaiSetup} from './utils/chai_setup';
 import {web3Factory} from './utils/web3_factory';
 import {ZeroEx, Token} from '../src';

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

@@ -2,7 +2,7 @@ import 'mocha';
 import * as chai from 'chai';
 import {chaiSetup} from './utils/chai_setup';
 import * as Web3 from 'web3';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import promisify = require('es6-promisify');
 import {web3Factory} from './utils/web3_factory';
 import {
@@ -17,6 +17,7 @@ import {
     TokenContractEventArgs,
     LogWithDecodedArgs,
     LogEvent,
+    DecodedLogEvent,
 } from '../src';
 import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
 import {TokenUtils} from './utils/token_utils';
@@ -51,7 +52,7 @@ describe('TokenWrapper', () => {
     });
     describe('#transferAsync', () => {
         let token: Token;
-        let transferAmount: BigNumber.BigNumber;
+        let transferAmount: BigNumber;
         before(() => {
             token = tokens[0];
             transferAmount = new BigNumber(42);
@@ -62,7 +63,7 @@ describe('TokenWrapper', () => {
             const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
             expect(preBalance).to.be.bignumber.equal(0);
             const txHash = await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
-            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const receipt = await zeroEx.awaitTransactionMinedAsync(txHash);
             const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
             return expect(postBalance).to.be.bignumber.equal(transferAmount);
         });
@@ -161,7 +162,7 @@ describe('TokenWrapper', () => {
                 const token = tokens[0];
                 const ownerAddress = coinbase;
                 const balance = await zeroEx.token.getBalanceAsync(token.address, ownerAddress);
-                const expectedBalance = new BigNumber('100000000000000000000000000');
+                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 () => {
@@ -189,7 +190,7 @@ describe('TokenWrapper', () => {
                     const token = tokens[0];
                     const ownerAddress = coinbase;
                     const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
-                    const expectedBalance = new BigNumber('100000000000000000000000000');
+                    const expectedBalance = new BigNumber('1000000000000000000000000000');
                     return expect(balance).to.be.bignumber.equal(expectedBalance);
             });
         });
@@ -358,7 +359,7 @@ describe('TokenWrapper', () => {
         // Source: https://github.com/mochajs/mocha/issues/2407
         it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
             (async () => {
-                const callback = (logEvent: LogEvent<TransferContractEventArgs>) => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
                     expect(logEvent).to.not.be.undefined();
                     const args = logEvent.args;
                     expect(args._from).to.be.equal(coinbase);
@@ -373,7 +374,7 @@ describe('TokenWrapper', () => {
         });
         it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
             (async () => {
-                const callback = (logEvent: LogEvent<ApprovalContractEventArgs>) => {
+                const callback = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                     expect(logEvent).to.not.be.undefined();
                     const args = logEvent.args;
                     expect(args._owner).to.be.equal(coinbase);
@@ -388,13 +389,13 @@ describe('TokenWrapper', () => {
         });
         it('Outstanding subscriptions are cancelled when zeroEx.setProviderAsync called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = (logEvent: LogEvent<TransferContractEventArgs>) => {
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                     done(new Error('Expected this subscription to have been cancelled'));
                 };
                 zeroEx.token.subscribe(
                     tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled,
                 );
-                const callbackToBeCalled = (logEvent: LogEvent<TransferContractEventArgs>) => {
+                const callbackToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                     done();
                 };
                 const newProvider = web3Factory.getRpcProvider();
@@ -407,7 +408,7 @@ describe('TokenWrapper', () => {
         });
         it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
             (async () => {
-                const callbackNeverToBeCalled = (logEvent: LogEvent<TokenContractEventArgs>) => {
+                const callbackNeverToBeCalled = (err: Error, logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
                     done(new Error('Expected this subscription to have been cancelled'));
                 };
                 const subscriptionToken = zeroEx.token.subscribe(

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

@@ -20,4 +20,7 @@ export class BlockchainLifecycle {
             throw new Error(`Snapshot with id #${snapshotId} failed to revert`);
         }
     }
+    public async mineABlock(): Promise<void> {
+        await this.rpc.mineBlockAsync();
+    }
 }

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

@@ -1,4 +1,4 @@
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {ZeroEx, Token, SignedOrder} from '../../src';
 import {orderFactory} from '../utils/order_factory';
 import {constants} from './constants';
@@ -21,8 +21,8 @@ export class FillScenarios {
     }
     public async createFillableSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
                                                 makerAddress: string, takerAddress: string,
-                                                fillableAmount: BigNumber.BigNumber,
-                                                expirationUnixTimestampSec?: BigNumber.BigNumber):
+                                                fillableAmount: BigNumber,
+                                                expirationUnixTimestampSec?: BigNumber):
                                            Promise<SignedOrder> {
         return this.createAsymmetricFillableSignedOrderAsync(
             makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
@@ -31,10 +31,10 @@ export class FillScenarios {
     }
     public async createFillableSignedOrderWithFeesAsync(
         makerTokenAddress: string, takerTokenAddress: string,
-        makerFee: BigNumber.BigNumber, takerFee: BigNumber.BigNumber,
+        makerFee: BigNumber, takerFee: BigNumber,
         makerAddress: string, takerAddress: string,
-        fillableAmount: BigNumber.BigNumber,
-        feeRecepient: string, expirationUnixTimestampSec?: BigNumber.BigNumber,
+        fillableAmount: BigNumber,
+        feeRecepient: string, expirationUnixTimestampSec?: BigNumber,
     ): Promise<SignedOrder> {
         return this.createAsymmetricFillableSignedOrderWithFeesAsync(
             makerTokenAddress, takerTokenAddress, makerFee, takerFee, makerAddress, takerAddress,
@@ -43,8 +43,8 @@ export class FillScenarios {
     }
     public async createAsymmetricFillableSignedOrderAsync(
         makerTokenAddress: string, takerTokenAddress: string, makerAddress: string, takerAddress: string,
-        makerFillableAmount: BigNumber.BigNumber, takerFillableAmount: BigNumber.BigNumber,
-        expirationUnixTimestampSec?: BigNumber.BigNumber): Promise<SignedOrder> {
+        makerFillableAmount: BigNumber, takerFillableAmount: BigNumber,
+        expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
         const makerFee = new BigNumber(0);
         const takerFee = new BigNumber(0);
         const feeRecepient = constants.NULL_ADDRESS;
@@ -54,8 +54,8 @@ export class FillScenarios {
         );
     }
     public async createPartiallyFilledSignedOrderAsync(makerTokenAddress: string, takerTokenAddress: string,
-                                                       takerAddress: string, fillableAmount: BigNumber.BigNumber,
-                                                       partialFillAmount: BigNumber.BigNumber) {
+                                                       takerAddress: string, fillableAmount: BigNumber,
+                                                       partialFillAmount: BigNumber) {
         const [makerAddress] = this.userAddresses;
         const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
             makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
@@ -69,10 +69,10 @@ export class FillScenarios {
     }
     private async createAsymmetricFillableSignedOrderWithFeesAsync(
         makerTokenAddress: string, takerTokenAddress: string,
-        makerFee: BigNumber.BigNumber, takerFee: BigNumber.BigNumber,
+        makerFee: BigNumber, takerFee: BigNumber,
         makerAddress: string, takerAddress: string,
-        makerFillableAmount: BigNumber.BigNumber, takerFillableAmount: BigNumber.BigNumber,
-        feeRecepient: string, expirationUnixTimestampSec?: BigNumber.BigNumber): Promise<SignedOrder> {
+        makerFillableAmount: BigNumber, takerFillableAmount: BigNumber,
+        feeRecepient: string, expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
 
         await Promise.all([
             this.increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
@@ -90,7 +90,7 @@ export class FillScenarios {
         return signedOrder;
     }
     private async increaseBalanceAndAllowanceAsync(
-        tokenAddress: string, address: string, amount: BigNumber.BigNumber): Promise<void> {
+        tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
         if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
             return; // noop
         }
@@ -100,11 +100,11 @@ export class FillScenarios {
         ]);
     }
     private async increaseBalanceAsync(
-        tokenAddress: string, address: string, amount: BigNumber.BigNumber): Promise<void> {
+        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.BigNumber): Promise<void> {
+        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(

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

@@ -1,5 +1,5 @@
 import * as _ from 'lodash';
-import * as BigNumber from 'bignumber.js';
+import BigNumber from 'bignumber.js';
 import {ZeroEx, SignedOrder} from '../../src';
 
 export const orderFactory = {
@@ -7,15 +7,15 @@ export const orderFactory = {
         zeroEx: ZeroEx,
         maker: string,
         taker: string,
-        makerFee: BigNumber.BigNumber,
-        takerFee: BigNumber.BigNumber,
-        makerTokenAmount: BigNumber.BigNumber,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerTokenAmount: BigNumber,
         makerTokenAddress: string,
-        takerTokenAmount: BigNumber.BigNumber,
+        takerTokenAmount: BigNumber,
         takerTokenAddress: string,
         exchangeContractAddress: string,
         feeRecipient: string,
-        expirationUnixTimestampSec?: BigNumber.BigNumber): Promise<SignedOrder> {
+        expirationUnixTimestampSec?: BigNumber): Promise<SignedOrder> {
         const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
         expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSec) ?
             defaultExpirationUnixTimestampSec :

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

@@ -0,0 +1,14 @@
+import { DoneCallback } from '../../src/types';
+
+export const reportCallbackErrors = (done: DoneCallback) => {
+    return (f: (...args: any[]) => void) => {
+        const wrapped = (...args: any[]) => {
+            try {
+                f(...args);
+            } catch (err) {
+                done(err);
+            }
+        };
+        return wrapped;
+    };
+};

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

@@ -26,6 +26,12 @@ export class RPC {
         const didRevert = await this.sendAsync(payload);
         return didRevert;
     }
+    public async mineBlockAsync(): Promise<void> {
+        const method = 'evm_mine';
+        const params: any[] = [];
+        const payload = this.toPayload(method, params);
+        await this.sendAsync(payload);
+    }
     private toPayload(method: string, params: any[] = []): string {
         const payload = JSON.stringify({
             id: this.id,

packages/0x.js/tsconfig.json

@@ -13,10 +13,10 @@
   "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"
+    "../../node_modules/types-bn/index.d.ts",
+    "../../node_modules/types-ethereumjs-util/index.d.ts",
+    "../../node_modules/web3-typescript-typings/index.d.ts",
+    "../../node_modules/chai-typescript-typings/index.d.ts",
+    "../../node_modules/chai-as-promised-typescript-typings/index.d.ts"
   ]
 }

packages/0x.js/tslint.json

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

packages/assert/README.md

@@ -0,0 +1 @@
+Standard type and schema assertions to be used across all 0x projects and packages

packages/assert/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@0xproject/assert",
+  "version": "0.0.4",
+  "description": "Provides a standard way of performing type and schema validation across 0x projects",
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "shx rm -rf _bundles lib test_temp",
+    "lint": "tslint src/**/*.ts test/**/*.ts",
+    "run_mocha": "mocha lib/test/**/*_test.js",
+    "prepublishOnly": "run-p build",
+    "test": "run-s clean build run_mocha",
+    "test:circleci": "yarn test"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xProject/0x.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/0xProject/0x.js/issues"
+  },
+  "homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
+  "devDependencies": {
+    "@0xproject/tslint-config": "^0.1.0",
+    "@types/lodash": "^4.14.78",
+    "@types/mocha": "^2.2.42",
+    "@types/valid-url": "^1.0.2",
+    "chai": "^4.0.1",
+    "chai-typescript-typings": "^0.0.1",
+    "dirty-chai": "^2.0.1",
+    "mocha": "^4.0.1",
+    "npm-run-all": "^4.1.1",
+    "shx": "^0.2.2",
+    "tslint": "5.8.0",
+    "typescript": "^2.4.2"
+  },
+  "dependencies": {
+    "@0xproject/json-schemas": "^0.6.7",
+    "bignumber.js": "~4.1.0",
+    "ethereum-address": "^0.0.4",
+    "lodash": "^4.17.4",
+    "valid-url": "^1.0.9"
+  }
+}

packages/assert/src/globals.d.ts

@@ -0,0 +1,5 @@
+declare module 'dirty-chai';
+
+declare module 'ethereum-address' {
+    const isAddress: (arg: any) => boolean;
+}

packages/assert/src/index.ts

@@ -1,16 +1,26 @@
+import BigNumber from 'bignumber.js';
+import * as ethereum_address from 'ethereum-address';
 import * as _ from 'lodash';
-import * as BigNumber from 'bignumber.js';
-import * as Web3 from 'web3';
-import {Web3Wrapper} from '../web3_wrapper';
-import {SchemaValidator, Schema} from '0x-json-schemas';
+import * as validUrl from 'valid-url';
+import {
+    SchemaValidator,
+    Schema,
+} from '@0xproject/json-schemas';
 
 const HEX_REGEX = /^0x[0-9A-F]*$/i;
 
 export const assert = {
-    isBigNumber(variableName: string, value: BigNumber.BigNumber): void {
-        const isBigNumber = _.isObject(value) && value.isBigNumber;
+    isBigNumber(variableName: string, value: BigNumber): void {
+        const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
         this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
     },
+    isValidBaseUnitAmount(variableName: string, value: BigNumber) {
+        assert.isBigNumber(variableName, value);
+        const hasDecimals = value.decimalPlaces() !== 0;
+        this.assert(
+            !hasDecimals, `${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
+        );
+    },
     isUndefined(value: any, variableName?: string): void {
         this.assert(_.isUndefined(value), this.typeAssertionMessage(variableName, 'undefined', value));
     },
@@ -25,10 +35,9 @@ export const assert = {
             this.typeAssertionMessage(variableName, 'HexString', value));
     },
     isETHAddressHex(variableName: string, value: string): void {
-        const web3 = new Web3();
-        this.assert(web3.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
+        this.assert(ethereum_address.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
         this.assert(
-            web3.isAddress(value) && value.toLowerCase() === value,
+            ethereum_address.isAddress(value) && value.toLowerCase() === value,
             `Checksummed addresses are not supported. Convert ${variableName} to lower case before passing`,
         );
     },
@@ -43,18 +52,6 @@ export const assert = {
             `Expected ${variableName} to be one of: ${enumValuesAsString}, encountered: ${value}`,
         );
     },
-    async isSenderAddressAsync(variableName: string, senderAddressHex: string,
-                               web3Wrapper: Web3Wrapper): Promise<void> {
-        assert.isETHAddressHex(variableName, senderAddressHex);
-        const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddressHex);
-        assert.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');
-    },
     hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
         this.assert(_.uniq(value).length <= 1, errMsg);
     },
@@ -64,7 +61,7 @@ export const assert = {
     isBoolean(variableName: string, value: boolean): void {
         this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
     },
-    isWeb3Provider(variableName: string, value: Web3.Provider): void {
+    isWeb3Provider(variableName: string, value: any): void {
         const isWeb3Provider = _.isFunction((value as any).send) || _.isFunction((value as any).sendAsync);
         this.assert(isWeb3Provider, this.typeAssertionMessage(variableName, 'Web3.Provider', value));
     },
@@ -77,6 +74,14 @@ Encountered: ${JSON.stringify(value, null, '\t')}
 Validation errors: ${validationResult.errors.join(', ')}`;
         this.assert(!hasValidationErrors, msg);
     },
+    isHttpUrl(variableName: string, value: any): void {
+        const isValidUrl = validUrl.isWebUri(value);
+        this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
+    },
+    isUri(variableName: string, value: any): void {
+        const isValidUri = validUrl.isUri(value);
+        this.assert(isValidUri, this.typeAssertionMessage(variableName, 'uri', value));
+    },
     assert(condition: boolean, message: string): void {
         if (!condition) {
             throw new Error(message);

packages/assert/test/assert_test.ts

@@ -0,0 +1,338 @@
+import 'mocha';
+import * as dirtyChai from 'dirty-chai';
+import * as chai from 'chai';
+import {BigNumber} from 'bignumber.js';
+import {schemas} from '@0xproject/json-schemas';
+import {assert} from '../src/index';
+
+chai.config.includeStack = true;
+chai.use(dirtyChai);
+const expect = chai.expect;
+
+describe('Assertions', () => {
+    const variableName = 'variable';
+    describe('#isBigNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                new BigNumber(23),
+                new BigNumber('45'),
+            ];
+            validInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                'test',
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+            ];
+            invalidInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isUndefined', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                undefined,
+            ];
+            validInputs.forEach(input => expect(assert.isUndefined.bind(assert, input, variableName)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                'test',
+                42,
+                false,
+                { random: 'test' },
+            ];
+            invalidInputs.forEach(input => expect(assert.isUndefined.bind(assert, input, variableName)).to.throw());
+        });
+    });
+    describe('#isString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'hello',
+                'goodbye',
+            ];
+            validInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isFunction', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                BigNumber,
+                assert.isString.bind(this),
+            ];
+            validInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isHexString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
+                '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
+            ];
+            validInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x61a3ed31B43c8780e905a260a35faYfEc527be7516aa11c0256729b5b351bc33',
+            ];
+            invalidInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isETHAddressHex', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x0000000000000000000000000000000000000000',
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#doesBelongToStringEnum', () => {
+        enum TestEnums {
+            Test1 = 'Test1',
+            Test2 = 'Test2',
+        }
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                TestEnums.Test1,
+                TestEnums.Test2,
+            ];
+            validInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.throw(),
+            );
+        });
+    });
+    describe('#hasAtMostOneUniqueValue', () => {
+        const errorMsg = 'more than one unique value';
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                ['hello'],
+                ['goodbye', 'goodbye', 'goodbye'],
+            ];
+            validInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                ['hello', 'goodbye'],
+                ['goodbye', 42, false, false],
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.throw(),
+            );
+        });
+    });
+    describe('#isNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                42,
+                0.00,
+                21e+42,
+            ];
+            validInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isBoolean', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                true,
+                false,
+            ];
+            validInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isWeb3Provider', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                { send: () => 45 },
+                { sendAsync: () => 45 },
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#doesConformToSchema', () => {
+        const schema = schemas.addressSchema;
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.throw(),
+            );
+        });
+    });
+    describe('#isHttpUrl', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isHttpUrl.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'ws://www.api.example-relayer.net',
+                'www.google.com',
+                'api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isHttpUrl.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#isUri', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+                'ws://www.api.example-relayer.net',
+                'wss://www.api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isUri.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'www.google.com',
+                'api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isUri.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#assert', () => {
+        const assertMessage = 'assert not satisfied';
+        it('should not throw for valid input', () => {
+            expect(assert.assert.bind(assert, true, assertMessage)).to.not.throw();
+        });
+        it('should throw for invalid input', () => {
+            expect(assert.assert.bind(assert, false, assertMessage)).to.throw();
+        });
+    });
+    describe('#typeAssertionMessage', () => {
+        it('should render correct message', () => {
+            expect(assert.typeAssertionMessage('variable', 'string', 'number'))
+            .to.equal(`Expected variable to be of type string, encountered: number`);
+        });
+    });
+});

packages/assert/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [ "es2017", "dom"],
+    "outDir": "lib",
+    "sourceMap": true,
+    "declaration": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true
+  },
+  "include": [
+    "./src/**/*",
+    "./test/**/*",
+    "../../node_modules/chai-typescript-typings/index.d.ts",
+    "../../node_modules/web3-typescript-typings/index.d.ts"
+  ]
+}

packages/assert/tslint.json

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

packages/json-schemas/README.md

@@ -0,0 +1,15 @@
+Contains 0x-related json schemas
+
+## Usage:
+```
+import {SchemaValidator, ValidatorResult, schemas} from '@0xproject/json-schemas';
+
+const {orderSchema} = schemas;
+const validator = new SchemaValidator();
+
+const order = {
+    ...
+};
+const validatorResult: ValidatorResult = validator.validate(order, orderSchema); // Contains all errors
+const isValid: boolean = validator.isValid(order, orderSchema); // Only returns boolean
+```

packages/json-schemas/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@0xproject/json-schemas",
+  "version": "0.6.7",
+  "description": "0x-related json schemas",
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "scripts": {
+    "lint": "tslint src/*.ts test/*.ts",
+    "test": "run-s clean build run_mocha",
+    "test:circleci": "yarn test",
+    "run_mocha": "mocha lib/test/**/*_test.js",
+    "clean": "shx rm -rf _bundles lib test_temp",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xProject/0x.js.git"
+  },
+  "author": "",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/0xProject/0x.js/issues"
+  },
+  "homepage": "https://github.com/0xProject/0x.js/packages/json-schemas/README.md",
+  "dependencies": {
+    "es6-promisify": "^5.0.0",
+    "jsonschema": "^1.2.0",
+    "lodash.values": "^4.3.0"
+  },
+  "devDependencies": {
+    "@0xproject/tslint-config": "^0.1.0",
+    "@types/lodash.foreach": "^4.5.3",
+    "@types/lodash.values": "^4.3.3",
+    "@types/mocha": "^2.2.42",
+    "bignumber.js": "^4.0.2",
+    "chai": "^4.1.1",
+    "chai-typescript-typings": "^0.0.1",
+    "dirty-chai": "^2.0.1",
+    "lodash.foreach": "^4.5.0",
+    "mocha": "^4.0.1",
+    "npm-run-all": "^4.1.1",
+    "shx": "^0.2.2",
+    "tslint": "5.8.0",
+    "typescript": "~2.6.1"
+  }
+}

packages/json-schemas/schemas/basic_type_schemas.ts

@@ -0,0 +1,11 @@
+export const addressSchema = {
+    id: '/Address',
+    type: 'string',
+    pattern: '^0x[0-9a-f]{40}$',
+};
+
+export const numberSchema = {
+    id: '/Number',
+    type: 'string',
+    pattern: '^\\d+(\\.\\d+)?$',
+};

packages/json-schemas/schemas/ec_signature_schema.ts

@@ -0,0 +1,20 @@
+export const ecSignatureParameterSchema = {
+    id: '/ECSignatureParameter',
+    type: 'string',
+    pattern: '^0[xX][0-9A-Fa-f]{64}$',
+};
+
+export const ecSignatureSchema = {
+    id: '/ECSignature',
+    properties: {
+        v: {
+            type: 'number',
+            minimum: 27,
+            maximum: 28,
+        },
+        r: {$ref: '/ECSignatureParameter'},
+        s: {$ref: '/ECSignatureParameter'},
+    },
+    required: ['v', 'r', 's'],
+    type: 'object',
+};

packages/json-schemas/schemas/index_filter_values_schema.ts

@@ -0,0 +1,11 @@
+export const indexFilterValuesSchema = {
+    id: '/IndexFilterValues',
+    additionalProperties: {
+        oneOf: [
+            {$ref: '/Number'},
+            {$ref: '/Address'},
+            {$ref: '/OrderHashSchema'},
+        ],
+    },
+    type: 'object',
+};

packages/json-schemas/schemas/order_cancel_schema.ts

@@ -0,0 +1,12 @@
+export const orderCancellationRequestsSchema = {
+    id: '/OrderCancellationRequests',
+    type: 'array',
+    items: {
+        properties: {
+            order: {$ref: '/Order'},
+            takerTokenCancelAmount: {$ref: '/Number'},
+        },
+        required: ['order', 'takerTokenCancelAmount'],
+        type: 'object',
+    },
+};

packages/json-schemas/schemas/order_fill_or_kill_requests_schema.ts

@@ -0,0 +1,12 @@
+export const orderFillOrKillRequestsSchema = {
+    id: '/OrderFillOrKillRequests',
+    type: 'array',
+    items: {
+        properties: {
+            signedOrder: {$ref: '/SignedOrder'},
+            fillTakerAmount: {$ref: '/Number'},
+        },
+        required: ['signedOrder', 'fillTakerAmount'],
+        type: 'object',
+    },
+};

packages/json-schemas/schemas/order_fill_requests_schema.ts

@@ -0,0 +1,12 @@
+export const orderFillRequestsSchema = {
+    id: '/OrderFillRequests',
+    type: 'array',
+    items: {
+        properties: {
+            signedOrder: {$ref: '/SignedOrder'},
+            takerTokenFillAmount: {$ref: '/Number'},
+        },
+        required: ['signedOrder', 'takerTokenFillAmount'],
+        type: 'object',
+    },
+};

packages/json-schemas/schemas/order_hash_schema.ts

@@ -0,0 +1,5 @@
+export const orderHashSchema = {
+    id: '/OrderHashSchema',
+    type: 'string',
+    pattern: '^0x[0-9a-fA-F]{64}$',
+};

packages/json-schemas/schemas/order_schemas.ts

@@ -0,0 +1,35 @@
+export const orderSchema = {
+    id: '/Order',
+    properties: {
+        maker: {$ref: '/Address'},
+        taker: {$ref: '/Address'},
+        makerFee: {$ref: '/Number'},
+        takerFee: {$ref: '/Number'},
+        makerTokenAmount: {$ref: '/Number'},
+        takerTokenAmount: {$ref: '/Number'},
+        makerTokenAddress: {$ref: '/Address'},
+        takerTokenAddress: {$ref: '/Address'},
+        salt: {$ref: '/Number'},
+        feeRecipient: {$ref: '/Address'},
+        expirationUnixTimestampSec: {$ref: '/Number'},
+        exchangeContractAddress: {$ref: '/Address'},
+    },
+    required: [
+        'maker', 'taker', 'makerFee', 'takerFee', 'makerTokenAmount', 'takerTokenAmount',
+        'salt', 'feeRecipient', 'expirationUnixTimestampSec', 'exchangeContractAddress',
+    ],
+    type: 'object',
+};
+
+export const signedOrderSchema = {
+    id: '/SignedOrder',
+    allOf: [
+        { $ref: '/Order' },
+        {
+            properties: {
+                ecSignature: {$ref: '/ECSignature'},
+            },
+            required: ['ecSignature'],
+        },
+    ],
+};

packages/json-schemas/schemas/relayer_api_error_response_schema.ts

@@ -0,0 +1,21 @@
+export const relayerApiErrorResponseSchema = {
+    id: '/RelayerApiErrorResponse',
+    type: 'object',
+    properties: {
+        code: {type: 'number'},
+        reason: {type: 'string'},
+        validationErrors: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    field: {type: 'string'},
+                    code: {type: 'number'},
+                    reason: {type: 'string'},
+                },
+                required: ['field', 'code', 'reason'],
+            },
+        },
+    },
+    required: ['code', 'reason'],
+};

packages/json-schemas/schemas/relayer_api_fees_payload_schema.ts

@@ -0,0 +1,19 @@
+export const relayerApiFeesPayloadSchema = {
+    id: '/RelayerApiFeesPayload',
+    type: 'object',
+    properties: {
+        exchangeContractAddress: {$ref: '/Address'},
+        maker: {$ref: '/Address'},
+        taker: {$ref: '/Address'},
+        makerTokenAddress: {$ref: '/Address'},
+        takerTokenAddress: {$ref: '/Address'},
+        makerTokenAmount: {$ref: '/Number'},
+        takerTokenAmount: {$ref: '/Number'},
+        expirationUnixTimestampSec: {$ref: '/Number'},
+        salt: {$ref: '/Number'},
+    },
+    required: [
+        'exchangeContractAddress', 'maker', 'taker', 'makerTokenAddress', 'takerTokenAddress',
+        'expirationUnixTimestampSec', 'salt',
+    ],
+};

packages/json-schemas/schemas/relayer_api_fees_response_schema.ts

@@ -0,0 +1,10 @@
+export const relayerApiFeesResponseSchema = {
+    id: '/RelayerApiFeesResponse',
+    type: 'object',
+    properties: {
+        makerFee: {$ref: '/Number'},
+        takerFee: {$ref: '/Number'},
+        feeRecipient: {$ref: '/Address'},
+    },
+    required: ['makerFee', 'takerFee', 'feeRecipient'],
+};

packages/json-schemas/schemas/relayer_api_orberbook_channel_subscribe_schema.ts

@@ -0,0 +1,22 @@
+export const relayerApiOrderbookChannelSubscribeSchema = {
+    id: '/RelayerApiOrderbookChannelSubscribe',
+    type: 'object',
+    properties: {
+        type: {enum: ['subscribe']},
+        channel: {enum: ['orderbook']},
+        payload: {$ref: '/RelayerApiOrderbookChannelSubscribePayload'},
+    },
+    required: ['type', 'channel', 'payload'],
+};
+
+export const relayerApiOrderbookChannelSubscribePayload = {
+    id: '/RelayerApiOrderbookChannelSubscribePayload',
+    type: 'object',
+    properties: {
+        baseTokenAddress: {$ref: '/Address'},
+        quoteTokenAddress: {$ref: '/Address'},
+        snapshot: {type: 'boolean'},
+        limit: {type: 'number'},
+    },
+    required: ['baseTokenAddress', 'quoteTokenAddress'],
+};

packages/json-schemas/schemas/relayer_api_orderbook_channel_snapshot_schema.ts

@@ -0,0 +1,21 @@
+export const relayerApiOrderbookChannelSnapshotSchema = {
+    id: '/RelayerApiOrderbookChannelSnapshot',
+    type: 'object',
+    properties: {
+        type: {enum: ['snapshot']},
+        channel: {enum: ['orderbook']},
+        channelId: {type: 'number'},
+        payload: {$ref: '/RelayerApiOrderbookChannelSnapshotPayload'},
+    },
+    required: ['type', 'channel', 'channelId', 'payload'],
+};
+
+export const relayerApiOrderbookChannelSnapshotPayload = {
+    id: '/RelayerApiOrderbookChannelSnapshotPayload',
+    type: 'object',
+    properties: {
+        bids: {$ref: '/signedOrdersSchema'},
+        asks: {$ref: '/signedOrdersSchema'},
+    },
+    required: ['bids', 'asks'],
+};

packages/json-schemas/schemas/relayer_api_orderbook_channel_update_response_schema.ts

@@ -0,0 +1,11 @@
+export const relayerApiOrderbookChannelUpdateSchema = {
+    id: '/RelayerApiOrderbookChannelUpdate',
+    type: 'object',
+    properties: {
+        type: {enum: ['update']},
+        channel: {enum: ['orderbook']},
+        channelId: {type: 'number'},
+        payload: {$ref: '/SignedOrder'},
+    },
+    required: ['type', 'channel', 'channelId', 'payload'],
+};

packages/json-schemas/schemas/relayer_api_orderbook_response_schema.ts

@@ -0,0 +1,9 @@
+export const relayerApiOrderBookResponseSchema = {
+    id: '/RelayerApiOrderBookResponse',
+    type: 'object',
+    properties: {
+        bids: {$ref: '/signedOrdersSchema'},
+        asks: {$ref: '/signedOrdersSchema'},
+    },
+    required: ['bids', 'asks'],
+};

packages/json-schemas/schemas/relayer_api_token_pairs_response_schema.ts

@@ -0,0 +1,24 @@
+export const relayerApiTokenPairsResponseSchema = {
+    id: '/RelayerApiTokenPairsResponse',
+    type: 'array',
+    items: {
+        properties: {
+            tokenA: {$ref: '/RelayerApiTokenTradeInfo'},
+            tokenB: {$ref: '/RelayerApiTokenTradeInfo'},
+        },
+        required: ['tokenA', 'tokenB'],
+        type: 'object',
+    },
+};
+
+export const relayerApiTokenTradeInfoSchema = {
+    id: '/RelayerApiTokenTradeInfo',
+    type: 'object',
+    properties: {
+        address: {$ref: '/Address'},
+        minAmount: {$ref: '/Number'},
+        maxAmount: {$ref: '/Number'},
+        precision: {type: 'number'},
+    },
+    required: ['address'],
+};

packages/json-schemas/schemas/signed_orders_schema.ts

@@ -0,0 +1,5 @@
+export const signedOrdersSchema = {
+    id: '/signedOrdersSchema',
+    type: 'array',
+    items: {$ref: '/SignedOrder'},
+};