Merge branch 'development' into syncSubscribe

15 files changed, 149 insertions, 92 deletions

diff --git a/packages/0x.js/CHANGELOG.md b/packages/0x.js/CHANGELOG.md
index d5e965ed7..0112ca33f 100644
--- a/packages/0x.js/CHANGELOG.md
+++ b/packages/0x.js/CHANGELOG.md
@@ -3,10 +3,10 @@
 vx.x.x
 ------------------------
     * Remove support for Async callback types when used in Subscribe functions
-
-v0.24.0 - _November 13, 2017_
+v0.25.1 - _November 13, 2017_
 ------------------------
     * Standardise on Cancelled over Canceled
+    * Add missing `DecodedLogEvent` type to exported types
 
 v0.23.0 - _November 12, 2017_
 ------------------------
diff --git a/packages/0x.js/README.md b/packages/0x.js/README.md
index 4b6cc8df4..6cdcbde70 100644
--- a/packages/0x.js/README.md
+++ b/packages/0x.js/README.md
@@ -1,3 +1,6 @@
+0x.js
+-----
+
 ## Installation
 
 0x.js ships as both a [UMD](https://github.com/umdjs/umd) module and a [CommonJS](https://en.wikipedia.org/wiki/CommonJS) package.
diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json
index 6839e6513..0204d723f 100644
--- a/packages/0x.js/package.json
+++ b/packages/0x.js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "0x.js",
-  "version": "0.23.0",
+  "version": "0.25.1",
   "description": "A javascript library for interacting with the 0x protocol",
   "keywords": [
     "0x.js",
@@ -13,7 +13,7 @@
   "types": "lib/src/index.d.ts",
   "scripts": {
     "prebuild": "npm run clean",
-    "build": "run-p build:umd:prod build:commonjs",
+    "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",
@@ -49,6 +49,7 @@
     "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",
@@ -76,8 +77,7 @@
     "sinon": "^4.0.0",
     "source-map-support": "^0.5.0",
     "truffle-hdwallet-provider": "^0.0.3",
-    "tslint": "~5.5.0",
-    "tslint-config-0xproject": "^0.0.2",
+    "tslint": "5.8.0",
     "typedoc": "~0.8.0",
     "types-bn": "^0.0.1",
     "types-ethereumjs-util": "0xProject/types-ethereumjs-util",
@@ -87,9 +87,10 @@
     "webpack": "^3.1.0"
   },
   "dependencies": {
-    "@0xproject/assert": "0.0.3",
-    "0x-json-schemas": "^0.6.1",
+    "@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",
diff --git a/packages/0x.js/src/0x.ts b/packages/0x.js/src/0x.ts
index fe765bbbe..85c2b7724 100644
--- a/packages/0x.js/src/0x.ts
+++ b/packages/0x.js/src/0x.ts
@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
 import BigNumber from 'bignumber.js';
-import {SchemaValidator, schemas} from '0x-json-schemas';
+import {SchemaValidator, schemas} from '@0xproject/json-schemas';
 import {bigNumberConfigs} from './bignumber_config';
 import * as ethUtil from 'ethereumjs-util';
 import {Web3Wrapper} from './web3_wrapper';
diff --git a/packages/0x.js/src/contract.ts b/packages/0x.js/src/contract.ts
index 1aacc65dc..7ccd336d6 100644
--- a/packages/0x.js/src/contract.ts
+++ b/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 {
diff --git a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts
index 5acfd3cc9..3e631b73e 100644
--- a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts
+++ b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts
@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
 import BigNumber from 'bignumber.js';
-import {schemas} from '0x-json-schemas';
+import {schemas} from '@0xproject/json-schemas';
 import {Web3Wrapper} from '../web3_wrapper';
 import {
     ECSignature,
diff --git a/packages/0x.js/src/contract_wrappers/token_wrapper.ts b/packages/0x.js/src/contract_wrappers/token_wrapper.ts
index 614ac19d4..4b89d3cfc 100644
--- a/packages/0x.js/src/contract_wrappers/token_wrapper.ts
+++ b/packages/0x.js/src/contract_wrappers/token_wrapper.ts
@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
 import BigNumber from 'bignumber.js';
-import {schemas} from '0x-json-schemas';
+import {schemas} from '@0xproject/json-schemas';
 import {Web3Wrapper} from '../web3_wrapper';
 import {assert} from '../utils/assert';
 import {constants} from '../utils/constants';
diff --git a/packages/0x.js/src/order_watcher/order_state_watcher.ts b/packages/0x.js/src/order_watcher/order_state_watcher.ts
index 80f323017..1b410dad1 100644
--- a/packages/0x.js/src/order_watcher/order_state_watcher.ts
+++ b/packages/0x.js/src/order_watcher/order_state_watcher.ts
@@ -1,5 +1,5 @@
 import * as _ from 'lodash';
-import {schemas} from '0x-json-schemas';
+import {schemas} from '@0xproject/json-schemas';
 import {ZeroEx} from '../0x';
 import {EventWatcher} from './event_watcher';
 import {assert} from '../utils/assert';
diff --git a/packages/0x.js/src/types.ts b/packages/0x.js/src/types.ts
index 91e3c0f20..39e5fa9f2 100644
--- a/packages/0x.js/src/types.ts
+++ b/packages/0x.js/src/types.ts
@@ -485,6 +485,7 @@ export interface OrderRelevantState {
     filledTakerTokenAmount: BigNumber;
     cancelledTakerTokenAmount: BigNumber;
     remainingFillableMakerTokenAmount: BigNumber;
+    remainingFillableTakerTokenAmount: BigNumber;
 }
 
 export interface OrderStateValid {
diff --git a/packages/0x.js/src/utils/abi_decoder.ts b/packages/0x.js/src/utils/abi_decoder.ts
index 840ad9be0..df0fb2d6f 100644
--- a/packages/0x.js/src/utils/abi_decoder.ts
+++ b/packages/0x.js/src/utils/abi_decoder.ts
@@ -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;
diff --git a/packages/0x.js/src/utils/assert.ts b/packages/0x.js/src/utils/assert.ts
index 4aa83ef17..55912525c 100644
--- a/packages/0x.js/src/utils/assert.ts
+++ b/packages/0x.js/src/utils/assert.ts
@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
 import BigNumber from 'bignumber.js';
-import {SchemaValidator, Schema} from '0x-json-schemas';
+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';
@@ -9,7 +9,8 @@ import {ECSignature} from '../types';
 
 const HEX_REGEX = /^0x[0-9A-F]*$/i;
 
-export const assert = _.extend({}, sharedAssert, {
+export const assert = {
+    ...sharedAssert,
     isValidSignature(orderHash: string, ecSignature: ECSignature, signerAddress: string) {
         const isValidSignature = signatureUtils.isValidSignature(orderHash, ecSignature, signerAddress);
         this.assert(isValidSignature, `Expected order with hash '${orderHash}' to have a valid signature`);
@@ -26,4 +27,4 @@ export const assert = _.extend({}, sharedAssert, {
         const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
         this.assert(!_.isEmpty(availableAddresses), 'No addresses were available on the provided web3 provider');
     },
-});
+};
diff --git a/packages/0x.js/src/utils/order_state_utils.ts b/packages/0x.js/src/utils/order_state_utils.ts
index a1ee7577d..123584f90 100644
--- a/packages/0x.js/src/utils/order_state_utils.ts
+++ b/packages/0x.js/src/utils/order_state_utils.ts
@@ -18,6 +18,8 @@ import {constants} from '../utils/constants';
 import {OrderFilledCancelledLazyStore} from '../stores/order_filled_cancelled_lazy_store';
 import {BalanceAndProxyAllowanceLazyStore} from '../stores/balance_proxy_allowance_lazy_store';
 
+const ACCEPTABLE_RELATIVE_ROUNDING_ERROR = 0.0001;
+
 export class OrderStateUtils {
     private balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
     private orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
@@ -78,6 +80,9 @@ export class OrderStateUtils {
                                                                    .dividedToIntegerBy(totalTakerTokenAmount);
         const fillableMakerTokenAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
         const remainingFillableMakerTokenAmount = BigNumber.min(fillableMakerTokenAmount, remainingMakerTokenAmount);
+        const remainingFillableTakerTokenAmount = remainingFillableMakerTokenAmount
+                                                  .times(totalTakerTokenAmount)
+                                                  .dividedToIntegerBy(totalMakerTokenAmount);
         // TODO: Handle edge case where maker token is ZRX with fee
         const orderRelevantState = {
             makerBalance,
@@ -87,6 +92,7 @@ export class OrderStateUtils {
             filledTakerTokenAmount,
             cancelledTakerTokenAmount,
             remainingFillableMakerTokenAmount,
+            remainingFillableTakerTokenAmount,
         };
         return orderRelevantState;
     }
@@ -113,6 +119,13 @@ export class OrderStateUtils {
                 throw new Error(ExchangeContractErrs.InsufficientMakerFeeAllowance);
             }
         }
+        const minFillableTakerTokenAmountWithinNoRoundingErrorRange = signedOrder.takerTokenAmount
+                                                                      .dividedBy(ACCEPTABLE_RELATIVE_ROUNDING_ERROR)
+                                                                      .dividedBy(signedOrder.makerTokenAmount);
+        if (orderRelevantState.remainingFillableTakerTokenAmount
+            .lessThan(minFillableTakerTokenAmountWithinNoRoundingErrorRange)) {
+            throw new Error(ExchangeContractErrs.OrderFillRoundingError);
+        }
         // TODO Add linear function solver when maker token is ZRX #badass
         // Return the max amount that's fillable
     }
diff --git a/packages/0x.js/test/order_state_watcher_test.ts b/packages/0x.js/test/order_state_watcher_test.ts
index 32f493ee6..a112bac1d 100644
--- a/packages/0x.js/test/order_state_watcher_test.ts
+++ b/packages/0x.js/test/order_state_watcher_test.ts
@@ -47,7 +47,7 @@ describe('OrderStateWatcher', () => {
     let taker: string;
     let web3Wrapper: Web3Wrapper;
     let signedOrder: SignedOrder;
-    const fillableAmount = new BigNumber(5);
+    const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), 18);
     before(async () => {
         web3 = web3Factory.create();
         zeroEx = new ZeroEx(web3.currentProvider);
@@ -61,6 +61,12 @@ describe('OrderStateWatcher', () => {
         [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(
@@ -215,6 +221,8 @@ describe('OrderStateWatcher', () => {
                     const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
                     expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
                         remainingFillable);
+                    expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                        remainingFillable);
                     expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
                     if (eventCount === 2) {
                         done();
@@ -227,84 +235,92 @@ describe('OrderStateWatcher', () => {
                 );
             })().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,
-                  );
+        describe('remainingFillable(M|T)akerTokenAmount', () => {
+            it('should calculate correct remaining fillable', (done: DoneCallback) => {
+                (async () => {
+                    const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), 18);
+                    const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), 18);
+                    signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                        makerToken.address, takerToken.address, maker, taker, makerFillableAmount,
+                        takerFillableAmount,
+                    );
+                    const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                    const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+                    const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
+                    const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                    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(
+                            ZeroEx.toBaseUnitAmount(new BigNumber(16), 18));
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            ZeroEx.toBaseUnitAmount(new BigNumber(8), 18));
+                        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 makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
 
-                  const changedMakerApprovalAmount = new BigNumber(3);
-                  zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), 18);
+                    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 callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            changedMakerApprovalAmount);
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            changedMakerApprovalAmount);
+                        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 makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
 
-                  const remainingAmount = new BigNumber(1);
-                  const transferAmount = makerBalance.sub(remainingAmount);
-                  zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), 18);
+                    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);
-          });
+                    const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            remainingAmount);
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            remainingAmount);
+                        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 () => {
@@ -327,6 +343,28 @@ describe('OrderStateWatcher', () => {
                 await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
             })().catch(done);
         });
+        it('should emit orderStateInvalid when within rounding error range', (done: DoneCallback) => {
+            (async () => {
+                const remainingFillableAmountInBaseUnits = new BigNumber(100);
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address, takerToken.address, maker, taker, fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+                const callback = reportCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
+                    done();
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.exchange.cancelOrderAsync(
+                    signedOrder, fillableAmount.minus(remainingFillableAmountInBaseUnits),
+                );
+            })().catch(done);
+        });
         it('should emit orderStateValid when watched order partially cancelled', (done: DoneCallback) => {
             (async () => {
                 signedOrder = await fillScenarios.createFillableSignedOrderAsync(
diff --git a/packages/0x.js/test/token_registry_wrapper_test.ts b/packages/0x.js/test/token_registry_wrapper_test.ts
index 6b5dd517e..d3497451b 100644
--- a/packages/0x.js/test/token_registry_wrapper_test.ts
+++ b/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';
diff --git a/packages/0x.js/tslint.json b/packages/0x.js/tslint.json
index 5842a872a..a07795151 100644
--- a/packages/0x.js/tslint.json
+++ b/packages/0x.js/tslint.json
@@ -1,5 +1,5 @@
 {
   "extends": [
-    "tslint-config-0xproject"
+    "@0xproject/tslint-config"
   ]
 }