Add new underscore-privates rule to @0xproject/tslint-config and fix lint errors

9 files changed, 188 insertions, 188 deletions

diff --git a/packages/0x.js/src/order_watcher/expiration_watcher.ts b/packages/0x.js/src/order_watcher/expiration_watcher.ts
index 91e8151fd..e71f11129 100644
--- a/packages/0x.js/src/order_watcher/expiration_watcher.ts
+++ b/packages/0x.js/src/order_watcher/expiration_watcher.ts
@@ -14,62 +14,62 @@ const DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS = 50;
  * It stores them in a min heap by expiration time and checks for expired ones every `orderExpirationCheckingIntervalMs`
  */
 export class ExpirationWatcher {
-    private orderHashByExpirationRBTree: RBTree<string>;
-    private expiration: {[orderHash: string]: BigNumber} = {};
-    private orderExpirationCheckingIntervalMs: number;
-    private expirationMarginMs: number;
-    private orderExpirationCheckingIntervalIdIfExists?: NodeJS.Timer;
+    private _orderHashByExpirationRBTree: RBTree<string>;
+    private _expiration: {[orderHash: string]: BigNumber} = {};
+    private _orderExpirationCheckingIntervalMs: number;
+    private _expirationMarginMs: number;
+    private _orderExpirationCheckingIntervalIdIfExists?: NodeJS.Timer;
     constructor(expirationMarginIfExistsMs?: number,
                 orderExpirationCheckingIntervalIfExistsMs?: number) {
-        this.expirationMarginMs = expirationMarginIfExistsMs ||
+        this._expirationMarginMs = expirationMarginIfExistsMs ||
                                   DEFAULT_EXPIRATION_MARGIN_MS;
-        this.orderExpirationCheckingIntervalMs = expirationMarginIfExistsMs ||
+        this._orderExpirationCheckingIntervalMs = expirationMarginIfExistsMs ||
                                                  DEFAULT_ORDER_EXPIRATION_CHECKING_INTERVAL_MS;
-        const scoreFunction = (orderHash: string) => this.expiration[orderHash].toNumber();
+        const scoreFunction = (orderHash: string) => this._expiration[orderHash].toNumber();
         const comparator = (lhs: string, rhs: string) => scoreFunction(lhs) - scoreFunction(rhs);
-        this.orderHashByExpirationRBTree = new RBTree(comparator);
+        this._orderHashByExpirationRBTree = new RBTree(comparator);
     }
     public subscribe(callback: (orderHash: string) => void): void {
-        if (!_.isUndefined(this.orderExpirationCheckingIntervalIdIfExists)) {
+        if (!_.isUndefined(this._orderExpirationCheckingIntervalIdIfExists)) {
             throw new Error(ZeroExError.SubscriptionAlreadyPresent);
         }
-        this.orderExpirationCheckingIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
-            this.pruneExpiredOrders.bind(this, callback), this.orderExpirationCheckingIntervalMs,
+        this._orderExpirationCheckingIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
+            this._pruneExpiredOrders.bind(this, callback), this._orderExpirationCheckingIntervalMs,
         );
     }
     public unsubscribe(): void {
-        if (_.isUndefined(this.orderExpirationCheckingIntervalIdIfExists)) {
+        if (_.isUndefined(this._orderExpirationCheckingIntervalIdIfExists)) {
             throw new Error(ZeroExError.SubscriptionNotFound);
         }
-        intervalUtils.clearAsyncExcludingInterval(this.orderExpirationCheckingIntervalIdIfExists);
-        delete this.orderExpirationCheckingIntervalIdIfExists;
+        intervalUtils.clearAsyncExcludingInterval(this._orderExpirationCheckingIntervalIdIfExists);
+        delete this._orderExpirationCheckingIntervalIdIfExists;
     }
     public addOrder(orderHash: string, expirationUnixTimestampMs: BigNumber): void {
-        this.expiration[orderHash] = expirationUnixTimestampMs;
-        this.orderHashByExpirationRBTree.insert(orderHash);
+        this._expiration[orderHash] = expirationUnixTimestampMs;
+        this._orderHashByExpirationRBTree.insert(orderHash);
     }
     public removeOrder(orderHash: string): void {
-        this.orderHashByExpirationRBTree.remove(orderHash);
-        delete this.expiration[orderHash];
+        this._orderHashByExpirationRBTree.remove(orderHash);
+        delete this._expiration[orderHash];
     }
-    private pruneExpiredOrders(callback: (orderHash: string) => void): void {
+    private _pruneExpiredOrders(callback: (orderHash: string) => void): void {
         const currentUnixTimestampMs = utils.getCurrentUnixTimestampMs();
         while (true) {
-            const hasTrakedOrders = this.orderHashByExpirationRBTree.size === 0;
+            const hasTrakedOrders = this._orderHashByExpirationRBTree.size === 0;
             if (hasTrakedOrders) {
                 break;
             }
-            const nextOrderHashToExpire = this.orderHashByExpirationRBTree.min();
-            const hasNoExpiredOrders = this.expiration[nextOrderHashToExpire].greaterThan(
-                currentUnixTimestampMs.plus(this.expirationMarginMs),
+            const nextOrderHashToExpire = this._orderHashByExpirationRBTree.min();
+            const hasNoExpiredOrders = this._expiration[nextOrderHashToExpire].greaterThan(
+                currentUnixTimestampMs.plus(this._expirationMarginMs),
             );
-            const isSubscriptionActive = _.isUndefined(this.orderExpirationCheckingIntervalIdIfExists);
+            const isSubscriptionActive = _.isUndefined(this._orderExpirationCheckingIntervalIdIfExists);
             if (hasNoExpiredOrders || isSubscriptionActive) {
                 break;
             }
-            const orderHash = this.orderHashByExpirationRBTree.min();
-            this.orderHashByExpirationRBTree.remove(orderHash);
-            delete this.expiration[orderHash];
+            const orderHash = this._orderHashByExpirationRBTree.min();
+            this._orderHashByExpirationRBTree.remove(orderHash);
+            delete this._expiration[orderHash];
             callback(orderHash);
         }
     }
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 c4a9eb1ad..bba01eb43 100644
--- a/packages/0x.js/src/order_watcher/order_state_watcher.ts
+++ b/packages/0x.js/src/order_watcher/order_state_watcher.ts
@@ -108,7 +108,7 @@ export class OrderStateWatcher {
         const orderHash = ZeroEx.getOrderHashHex(signedOrder);
         assert.isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker);
         this._orderByOrderHash[orderHash] = signedOrder;
-        this.addToDependentOrderHashes(signedOrder, orderHash);
+        this._addToDependentOrderHashes(signedOrder, orderHash);
         const expirationUnixTimestampMs = signedOrder.expirationUnixTimestampSec.times(1000);
         this._expirationWatcher.addOrder(orderHash, expirationUnixTimestampMs);
     }
@@ -126,8 +126,8 @@ export class OrderStateWatcher {
         delete this._orderStateByOrderHashCache[orderHash];
         const exchange = (this._orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
         const zrxTokenAddress = exchange.getZRXTokenAddress();
-        this.removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
-        this.removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, orderHash);
+        this._removeFromDependentOrderHashes(signedOrder.maker, zrxTokenAddress, orderHash);
+        this._removeFromDependentOrderHashes(signedOrder.maker, signedOrder.makerTokenAddress, orderHash);
         this._expirationWatcher.removeOrder(orderHash);
     }
     /**
@@ -294,7 +294,7 @@ export class OrderStateWatcher {
             this._callbackIfExists(orderState);
         }
     }
-    private addToDependentOrderHashes(signedOrder: SignedOrder, orderHash: string): void {
+    private _addToDependentOrderHashes(signedOrder: SignedOrder, orderHash: string): void {
         if (_.isUndefined(this._dependentOrderHashes[signedOrder.maker])) {
             this._dependentOrderHashes[signedOrder.maker] = {};
         }
@@ -308,7 +308,7 @@ export class OrderStateWatcher {
         }
         this._dependentOrderHashes[signedOrder.maker][zrxTokenAddress].add(orderHash);
     }
-    private removeFromDependentOrderHashes(makerAddress: string, tokenAddress: string, orderHash: string) {
+    private _removeFromDependentOrderHashes(makerAddress: string, tokenAddress: string, orderHash: string) {
         this._dependentOrderHashes[makerAddress][tokenAddress].delete(orderHash);
         if (this._dependentOrderHashes[makerAddress][tokenAddress].size === 0) {
             delete this._dependentOrderHashes[makerAddress][tokenAddress];
diff --git a/packages/0x.js/src/order_watcher/remaining_fillable_calculator.ts b/packages/0x.js/src/order_watcher/remaining_fillable_calculator.ts
index e8601e678..ddf3b763b 100644
--- a/packages/0x.js/src/order_watcher/remaining_fillable_calculator.ts
+++ b/packages/0x.js/src/order_watcher/remaining_fillable_calculator.ts
@@ -3,69 +3,69 @@ import {BigNumber} from 'bignumber.js';
 import {SignedOrder} from '../types';
 
 export class RemainingFillableCalculator {
-    private signedOrder: SignedOrder;
-    private isMakerTokenZRX: boolean;
+    private _signedOrder: SignedOrder;
+    private _isMakerTokenZRX: boolean;
     // Transferrable Amount is the minimum of Approval and Balance
-    private transferrableMakerTokenAmount: BigNumber;
-    private transferrableMakerFeeTokenAmount: BigNumber;
-    private remainingMakerTokenAmount: BigNumber;
-    private remainingMakerFeeAmount: BigNumber;
+    private _transferrableMakerTokenAmount: BigNumber;
+    private _transferrableMakerFeeTokenAmount: BigNumber;
+    private _remainingMakerTokenAmount: BigNumber;
+    private _remainingMakerFeeAmount: BigNumber;
     constructor(signedOrder: SignedOrder,
                 isMakerTokenZRX: boolean,
                 transferrableMakerTokenAmount: BigNumber,
                 transferrableMakerFeeTokenAmount: BigNumber,
                 remainingMakerTokenAmount: BigNumber) {
-        this.signedOrder = signedOrder;
-        this.isMakerTokenZRX = isMakerTokenZRX;
-        this.transferrableMakerTokenAmount = transferrableMakerTokenAmount;
-        this.transferrableMakerFeeTokenAmount = transferrableMakerFeeTokenAmount;
-        this.remainingMakerTokenAmount = remainingMakerTokenAmount;
-        this.remainingMakerFeeAmount = remainingMakerTokenAmount.times(signedOrder.makerFee)
+        this._signedOrder = signedOrder;
+        this._isMakerTokenZRX = isMakerTokenZRX;
+        this._transferrableMakerTokenAmount = transferrableMakerTokenAmount;
+        this._transferrableMakerFeeTokenAmount = transferrableMakerFeeTokenAmount;
+        this._remainingMakerTokenAmount = remainingMakerTokenAmount;
+        this._remainingMakerFeeAmount = remainingMakerTokenAmount.times(signedOrder.makerFee)
                                                                 .dividedToIntegerBy(signedOrder.makerTokenAmount);
     }
     public computeRemainingMakerFillable(): BigNumber {
-        if (this.hasSufficientFundsForFeeAndTransferAmount()) {
-            return this.remainingMakerTokenAmount;
+        if (this._hasSufficientFundsForFeeAndTransferAmount()) {
+            return this._remainingMakerTokenAmount;
         }
-        if (this.signedOrder.makerFee.isZero()) {
-            return BigNumber.min(this.remainingMakerTokenAmount, this.transferrableMakerTokenAmount);
+        if (this._signedOrder.makerFee.isZero()) {
+            return BigNumber.min(this._remainingMakerTokenAmount, this._transferrableMakerTokenAmount);
         }
-        return this.calculatePartiallyFillableMakerTokenAmount();
+        return this._calculatePartiallyFillableMakerTokenAmount();
     }
     public computeRemainingTakerFillable(): BigNumber {
-        return this.computeRemainingMakerFillable().times(this.signedOrder.takerTokenAmount)
-                                                   .dividedToIntegerBy(this.signedOrder.makerTokenAmount);
+        return this.computeRemainingMakerFillable().times(this._signedOrder.takerTokenAmount)
+                                                   .dividedToIntegerBy(this._signedOrder.makerTokenAmount);
     }
-    private hasSufficientFundsForFeeAndTransferAmount(): boolean {
-        if (this.isMakerTokenZRX) {
-            const totalZRXTransferAmountRequired = this.remainingMakerTokenAmount.plus(this.remainingMakerFeeAmount);
-            const hasSufficientFunds = this.transferrableMakerTokenAmount.greaterThanOrEqualTo(
+    private _hasSufficientFundsForFeeAndTransferAmount(): boolean {
+        if (this._isMakerTokenZRX) {
+            const totalZRXTransferAmountRequired = this._remainingMakerTokenAmount.plus(this._remainingMakerFeeAmount);
+            const hasSufficientFunds = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
                                                                             totalZRXTransferAmountRequired);
             return hasSufficientFunds;
         } else {
-            const hasSufficientFundsForTransferAmount = this.transferrableMakerTokenAmount.greaterThanOrEqualTo(
-                                                            this.remainingMakerTokenAmount);
-            const hasSufficientFundsForFeeAmount = this.transferrableMakerFeeTokenAmount.greaterThanOrEqualTo(
-                                                       this.remainingMakerFeeAmount);
+            const hasSufficientFundsForTransferAmount = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
+                                                            this._remainingMakerTokenAmount);
+            const hasSufficientFundsForFeeAmount = this._transferrableMakerFeeTokenAmount.greaterThanOrEqualTo(
+                                                       this._remainingMakerFeeAmount);
             const hasSufficientFunds = hasSufficientFundsForTransferAmount && hasSufficientFundsForFeeAmount;
             return hasSufficientFunds;
         }
     }
-    private calculatePartiallyFillableMakerTokenAmount(): BigNumber {
+    private _calculatePartiallyFillableMakerTokenAmount(): BigNumber {
         // Given an order for 200 wei for 2 ZRXwei fee, find 100 wei for 1 ZRXwei. Order ratio is then 100:1
-        const orderToFeeRatio = this.signedOrder.makerTokenAmount.dividedBy(this.signedOrder.makerFee);
+        const orderToFeeRatio = this._signedOrder.makerTokenAmount.dividedBy(this._signedOrder.makerFee);
         // The number of times the maker can fill the order, if each fill only required the transfer of a single
         // baseUnit of fee tokens.
         // Given 2 ZRXwei, the maximum amount of times Maker can fill this order, in terms of fees, is 2
-        const fillableTimesInFeeTokenBaseUnits = BigNumber.min(this.transferrableMakerFeeTokenAmount,
-                                                               this.remainingMakerFeeAmount);
+        const fillableTimesInFeeTokenBaseUnits = BigNumber.min(this._transferrableMakerFeeTokenAmount,
+                                                               this._remainingMakerFeeAmount);
         // The number of times the Maker can fill the order, given the Maker Token Balance
         // Assuming a balance of 150 wei, and an orderToFeeRatio of 100:1, maker can fill this order 1 time.
-        let fillableTimesInMakerTokenUnits = this.transferrableMakerTokenAmount.dividedBy(orderToFeeRatio);
-        if (this.isMakerTokenZRX) {
+        let fillableTimesInMakerTokenUnits = this._transferrableMakerTokenAmount.dividedBy(orderToFeeRatio);
+        if (this._isMakerTokenZRX) {
             // If ZRX is the maker token, the Fee and the Maker amount need to be removed from the same pool;
             // 200 ZRXwei for 2ZRXwei fee can only be filled once (need 202 ZRXwei)
-            const totalZRXTokenPooled = this.transferrableMakerTokenAmount;
+            const totalZRXTokenPooled = this._transferrableMakerTokenAmount;
             // The purchasing power here is less as the tokens are taken from the same Pool
             // For every one number of fills, we have to take an extra ZRX out of the pool
             fillableTimesInMakerTokenUnits = totalZRXTokenPooled.dividedBy(
@@ -75,11 +75,11 @@ export class RemainingFillableCalculator {
         // When Ratio is not fully divisible there can be remainders which cannot be represented, so they are floored.
         // This can result in a RoundingError being thrown by the Exchange Contract.
         const partiallyFillableMakerTokenAmount = fillableTimesInMakerTokenUnits
-                                                     .times(this.signedOrder.makerTokenAmount)
-                                                     .dividedToIntegerBy(this.signedOrder.makerFee);
+                                                     .times(this._signedOrder.makerTokenAmount)
+                                                     .dividedToIntegerBy(this._signedOrder.makerFee);
         const partiallyFillableFeeTokenAmount = fillableTimesInFeeTokenBaseUnits
-                                                     .times(this.signedOrder.makerTokenAmount)
-                                                     .dividedToIntegerBy(this.signedOrder.makerFee);
+                                                     .times(this._signedOrder.makerTokenAmount)
+                                                     .dividedToIntegerBy(this._signedOrder.makerFee);
         const partiallyFillableAmount = BigNumber.min(partiallyFillableMakerTokenAmount,
                                                       partiallyFillableFeeTokenAmount);
         return partiallyFillableAmount;
diff --git a/packages/0x.js/src/stores/balance_proxy_allowance_lazy_store.ts b/packages/0x.js/src/stores/balance_proxy_allowance_lazy_store.ts
index cde1ef095..ce93a70da 100644
--- a/packages/0x.js/src/stores/balance_proxy_allowance_lazy_store.ts
+++ b/packages/0x.js/src/stores/balance_proxy_allowance_lazy_store.ts
@@ -8,77 +8,77 @@ import {BlockParamLiteral} from '../types';
  * Copy on read store for balances/proxyAllowances of tokens/accounts
  */
 export class BalanceAndProxyAllowanceLazyStore {
-    private token: TokenWrapper;
-    private defaultBlock: BlockParamLiteral;
-    private balance: {
+    private _token: TokenWrapper;
+    private _defaultBlock: BlockParamLiteral;
+    private _balance: {
         [tokenAddress: string]: {
             [userAddress: string]: BigNumber;
         };
     };
-    private proxyAllowance: {
+    private _proxyAllowance: {
         [tokenAddress: string]: {
             [userAddress: string]: BigNumber;
         };
     };
     constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
-        this.token = token;
-        this.defaultBlock = defaultBlock;
-        this.balance = {};
-        this.proxyAllowance = {};
+        this._token = token;
+        this._defaultBlock = defaultBlock;
+        this._balance = {};
+        this._proxyAllowance = {};
     }
     public async getBalanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
-        if (_.isUndefined(this.balance[tokenAddress]) || _.isUndefined(this.balance[tokenAddress][userAddress])) {
+        if (_.isUndefined(this._balance[tokenAddress]) || _.isUndefined(this._balance[tokenAddress][userAddress])) {
             const methodOpts = {
-                defaultBlock: this.defaultBlock,
+                defaultBlock: this._defaultBlock,
             };
-            const balance = await this.token.getBalanceAsync(tokenAddress, userAddress, methodOpts);
+            const balance = await this._token.getBalanceAsync(tokenAddress, userAddress, methodOpts);
             this.setBalance(tokenAddress, userAddress, balance);
         }
-        const cachedBalance = this.balance[tokenAddress][userAddress];
+        const cachedBalance = this._balance[tokenAddress][userAddress];
         return cachedBalance;
     }
     public setBalance(tokenAddress: string, userAddress: string, balance: BigNumber): void {
-        if (_.isUndefined(this.balance[tokenAddress])) {
-            this.balance[tokenAddress] = {};
+        if (_.isUndefined(this._balance[tokenAddress])) {
+            this._balance[tokenAddress] = {};
         }
-        this.balance[tokenAddress][userAddress] = balance;
+        this._balance[tokenAddress][userAddress] = balance;
     }
     public deleteBalance(tokenAddress: string, userAddress: string): void {
-        if (!_.isUndefined(this.balance[tokenAddress])) {
-            delete this.balance[tokenAddress][userAddress];
-            if (_.isEmpty(this.balance[tokenAddress])) {
-                delete this.balance[tokenAddress];
+        if (!_.isUndefined(this._balance[tokenAddress])) {
+            delete this._balance[tokenAddress][userAddress];
+            if (_.isEmpty(this._balance[tokenAddress])) {
+                delete this._balance[tokenAddress];
             }
         }
     }
     public async getProxyAllowanceAsync(tokenAddress: string, userAddress: string): Promise<BigNumber> {
-        if (_.isUndefined(this.proxyAllowance[tokenAddress]) ||
-            _.isUndefined(this.proxyAllowance[tokenAddress][userAddress])) {
+        if (_.isUndefined(this._proxyAllowance[tokenAddress]) ||
+            _.isUndefined(this._proxyAllowance[tokenAddress][userAddress])) {
             const methodOpts = {
-                defaultBlock: this.defaultBlock,
+                defaultBlock: this._defaultBlock,
             };
-            const proxyAllowance = await this.token.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
+            const proxyAllowance = await this._token.getProxyAllowanceAsync(tokenAddress, userAddress, methodOpts);
             this.setProxyAllowance(tokenAddress, userAddress, proxyAllowance);
         }
-        const cachedProxyAllowance = this.proxyAllowance[tokenAddress][userAddress];
+        const cachedProxyAllowance = this._proxyAllowance[tokenAddress][userAddress];
         return cachedProxyAllowance;
     }
     public setProxyAllowance(tokenAddress: string, userAddress: string, proxyAllowance: BigNumber): void {
-        if (_.isUndefined(this.proxyAllowance[tokenAddress])) {
-            this.proxyAllowance[tokenAddress] = {};
+        if (_.isUndefined(this._proxyAllowance[tokenAddress])) {
+            this._proxyAllowance[tokenAddress] = {};
         }
-        this.proxyAllowance[tokenAddress][userAddress] = proxyAllowance;
+        this._proxyAllowance[tokenAddress][userAddress] = proxyAllowance;
     }
     public deleteProxyAllowance(tokenAddress: string, userAddress: string): void {
-        if (!_.isUndefined(this.proxyAllowance[tokenAddress])) {
-            delete this.proxyAllowance[tokenAddress][userAddress];
-            if (_.isEmpty(this.proxyAllowance[tokenAddress])) {
-                delete this.proxyAllowance[tokenAddress];
+        if (!_.isUndefined(this._proxyAllowance[tokenAddress])) {
+            delete this._proxyAllowance[tokenAddress][userAddress];
+            if (_.isEmpty(this._proxyAllowance[tokenAddress])) {
+                delete this._proxyAllowance[tokenAddress];
             }
         }
     }
     public deleteAll(): void {
-        this.balance = {};
-        this.proxyAllowance = {};
+        this._balance = {};
+        this._proxyAllowance = {};
     }
 }
diff --git a/packages/0x.js/src/stores/order_filled_cancelled_lazy_store.ts b/packages/0x.js/src/stores/order_filled_cancelled_lazy_store.ts
index b35355e38..54e260a8e 100644
--- a/packages/0x.js/src/stores/order_filled_cancelled_lazy_store.ts
+++ b/packages/0x.js/src/stores/order_filled_cancelled_lazy_store.ts
@@ -8,54 +8,54 @@ import {BlockParamLiteral} from '../types';
  * Copy on read store for filled/cancelled taker amounts
  */
 export class OrderFilledCancelledLazyStore {
-    private exchange: ExchangeWrapper;
-    private filledTakerAmount: {
+    private _exchange: ExchangeWrapper;
+    private _filledTakerAmount: {
         [orderHash: string]: BigNumber;
     };
-    private cancelledTakerAmount: {
+    private _cancelledTakerAmount: {
         [orderHash: string]: BigNumber;
     };
     constructor(exchange: ExchangeWrapper) {
-        this.exchange = exchange;
-        this.filledTakerAmount = {};
-        this.cancelledTakerAmount = {};
+        this._exchange = exchange;
+        this._filledTakerAmount = {};
+        this._cancelledTakerAmount = {};
     }
     public async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
-        if (_.isUndefined(this.filledTakerAmount[orderHash])) {
+        if (_.isUndefined(this._filledTakerAmount[orderHash])) {
             const methodOpts = {
                 defaultBlock: BlockParamLiteral.Pending,
             };
-            const filledTakerAmount = await this.exchange.getFilledTakerAmountAsync(orderHash, methodOpts);
+            const filledTakerAmount = await this._exchange.getFilledTakerAmountAsync(orderHash, methodOpts);
             this.setFilledTakerAmount(orderHash, filledTakerAmount);
         }
-        const cachedFilled = this.filledTakerAmount[orderHash];
+        const cachedFilled = this._filledTakerAmount[orderHash];
         return cachedFilled;
     }
     public setFilledTakerAmount(orderHash: string, filledTakerAmount: BigNumber): void {
-        this.filledTakerAmount[orderHash] = filledTakerAmount;
+        this._filledTakerAmount[orderHash] = filledTakerAmount;
     }
     public deleteFilledTakerAmount(orderHash: string): void {
-        delete this.filledTakerAmount[orderHash];
+        delete this._filledTakerAmount[orderHash];
     }
     public async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber> {
-        if (_.isUndefined(this.cancelledTakerAmount[orderHash])) {
+        if (_.isUndefined(this._cancelledTakerAmount[orderHash])) {
             const methodOpts = {
                 defaultBlock: BlockParamLiteral.Pending,
             };
-            const cancelledTakerAmount = await this.exchange.getCancelledTakerAmountAsync(orderHash, methodOpts);
+            const cancelledTakerAmount = await this._exchange.getCancelledTakerAmountAsync(orderHash, methodOpts);
             this.setCancelledTakerAmount(orderHash, cancelledTakerAmount);
         }
-        const cachedCancelled = this.cancelledTakerAmount[orderHash];
+        const cachedCancelled = this._cancelledTakerAmount[orderHash];
         return cachedCancelled;
     }
     public setCancelledTakerAmount(orderHash: string, cancelledTakerAmount: BigNumber): void {
-        this.cancelledTakerAmount[orderHash] = cancelledTakerAmount;
+        this._cancelledTakerAmount[orderHash] = cancelledTakerAmount;
     }
     public deleteCancelledTakerAmount(orderHash: string): void {
-        delete this.cancelledTakerAmount[orderHash];
+        delete this._cancelledTakerAmount[orderHash];
     }
     public deleteAll(): void {
-        this.filledTakerAmount = {};
-        this.cancelledTakerAmount = {};
+        this._filledTakerAmount = {};
+        this._cancelledTakerAmount = {};
     }
 }
diff --git a/packages/0x.js/src/utils/abi_decoder.ts b/packages/0x.js/src/utils/abi_decoder.ts
index f26b057f0..6d15f1d6f 100644
--- a/packages/0x.js/src/utils/abi_decoder.ts
+++ b/packages/0x.js/src/utils/abi_decoder.ts
@@ -6,9 +6,9 @@ import * as SolidityCoder from 'web3/lib/solidity/coder';
 import {AbiType, ContractEventArgs, DecodedLogArgs, LogWithDecodedArgs, RawLog, SolidityTypes} from '../types';
 
 export class AbiDecoder {
-    private savedABIs: Web3.AbiDefinition[] = [];
-    private methodIds: {[signatureHash: string]: Web3.EventAbi} = {};
-    private static padZeros(address: string) {
+    private _savedABIs: Web3.AbiDefinition[] = [];
+    private _methodIds: {[signatureHash: string]: Web3.EventAbi} = {};
+    private static _padZeros(address: string) {
         let formatted = address;
         if (_.startsWith(formatted, '0x')) {
             formatted = formatted.slice(2);
@@ -18,13 +18,13 @@ export class AbiDecoder {
         return `0x${formatted}`;
     }
     constructor(abiArrays: Web3.AbiDefinition[][]) {
-        _.map(abiArrays, this.addABI.bind(this));
+        _.map(abiArrays, this._addABI.bind(this));
     }
     // This method can only decode logs from the 0x & ERC20 smart contracts
     public tryToDecodeLogOrNoop<ArgsType extends ContractEventArgs>(
         log: Web3.LogEntry): LogWithDecodedArgs<ArgsType>|RawLog {
         const methodId = log.topics[0];
-        const event = this.methodIds[methodId];
+        const event = this._methodIds[methodId];
         if (_.isUndefined(event)) {
             return log;
         }
@@ -41,7 +41,7 @@ export class AbiDecoder {
             // Indexed parameters are stored in topics. Non-indexed ones in decodedData
             let value = param.indexed ? log.topics[topicsIndex++] : decodedData[dataIndex++];
             if (param.type === SolidityTypes.Address) {
-                value = AbiDecoder.padZeros(new BigNumber(value).toString(16));
+                value = AbiDecoder._padZeros(new BigNumber(value).toString(16));
             } else if (param.type === SolidityTypes.Uint256 ||
                        param.type === SolidityTypes.Uint8 ||
                        param.type === SolidityTypes.Uint) {
@@ -56,14 +56,14 @@ export class AbiDecoder {
             args: decodedParams,
         };
     }
-    private addABI(abiArray: Web3.AbiDefinition[]): void {
+    private _addABI(abiArray: Web3.AbiDefinition[]): void {
         _.map(abiArray, (abi: Web3.AbiDefinition) => {
             if (abi.type === AbiType.Event) {
                 const signature = `${abi.name}(${_.map(abi.inputs, input => input.type).join(',')})`;
                 const signatureHash = new Web3().sha3(signature);
-                this.methodIds[signatureHash] = abi;
+                this._methodIds[signatureHash] = abi;
             }
         });
-        this.savedABIs = this.savedABIs.concat(abiArray);
+        this._savedABIs = this._savedABIs.concat(abiArray);
     }
 }
diff --git a/packages/0x.js/src/utils/exchange_transfer_simulator.ts b/packages/0x.js/src/utils/exchange_transfer_simulator.ts
index 2574bd9ac..8143112aa 100644
--- a/packages/0x.js/src/utils/exchange_transfer_simulator.ts
+++ b/packages/0x.js/src/utils/exchange_transfer_simulator.ts
@@ -34,16 +34,16 @@ const ERR_MSG_MAPPING = {
 };
 
 export class ExchangeTransferSimulator {
-    private store: BalanceAndProxyAllowanceLazyStore;
-    private UNLIMITED_ALLOWANCE_IN_BASE_UNITS: BigNumber;
-    private static throwValidationError(failureReason: FailureReason, tradeSide: TradeSide,
-                                        transferType: TransferType): never {
+    private _store: BalanceAndProxyAllowanceLazyStore;
+    private _UNLIMITED_ALLOWANCE_IN_BASE_UNITS: BigNumber;
+    private static _throwValidationError(failureReason: FailureReason, tradeSide: TradeSide,
+                                         transferType: TransferType): never {
         const errMsg = ERR_MSG_MAPPING[failureReason][tradeSide][transferType];
         throw new Error(errMsg);
     }
     constructor(token: TokenWrapper, defaultBlock: BlockParamLiteral) {
-        this.store = new BalanceAndProxyAllowanceLazyStore(token, defaultBlock);
-        this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS = token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+        this._store = new BalanceAndProxyAllowanceLazyStore(token, defaultBlock);
+        this._UNLIMITED_ALLOWANCE_IN_BASE_UNITS = token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
     }
     /**
      * Simulates transferFrom call performed by a proxy
@@ -57,33 +57,33 @@ export class ExchangeTransferSimulator {
     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);
+        const balance = await this._store.getBalanceAsync(tokenAddress, from);
+        const proxyAllowance = await this._store.getProxyAllowanceAsync(tokenAddress, from);
         if (proxyAllowance.lessThan(amountInBaseUnits)) {
-            ExchangeTransferSimulator.throwValidationError(FailureReason.ProxyAllowance, tradeSide, transferType);
+            ExchangeTransferSimulator._throwValidationError(FailureReason.ProxyAllowance, tradeSide, transferType);
         }
         if (balance.lessThan(amountInBaseUnits)) {
-            ExchangeTransferSimulator.throwValidationError(FailureReason.Balance, tradeSide, transferType);
+            ExchangeTransferSimulator._throwValidationError(FailureReason.Balance, tradeSide, transferType);
         }
-        await this.decreaseProxyAllowanceAsync(tokenAddress, from, amountInBaseUnits);
-        await this.decreaseBalanceAsync(tokenAddress, from, amountInBaseUnits);
-        await this.increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
+        await this._decreaseProxyAllowanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this._decreaseBalanceAsync(tokenAddress, from, amountInBaseUnits);
+        await this._increaseBalanceAsync(tokenAddress, to, amountInBaseUnits);
     }
-    private async decreaseProxyAllowanceAsync(tokenAddress: string, userAddress: string,
-                                              amountInBaseUnits: BigNumber): Promise<void> {
-        const proxyAllowance = await this.store.getProxyAllowanceAsync(tokenAddress, userAddress);
-        if (!proxyAllowance.eq(this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS)) {
-            this.store.setProxyAllowance(tokenAddress, userAddress, proxyAllowance.minus(amountInBaseUnits));
+    private async _decreaseProxyAllowanceAsync(tokenAddress: string, userAddress: string,
+                                               amountInBaseUnits: BigNumber): Promise<void> {
+        const proxyAllowance = await this._store.getProxyAllowanceAsync(tokenAddress, userAddress);
+        if (!proxyAllowance.eq(this._UNLIMITED_ALLOWANCE_IN_BASE_UNITS)) {
+            this._store.setProxyAllowance(tokenAddress, userAddress, proxyAllowance.minus(amountInBaseUnits));
         }
     }
-    private async increaseBalanceAsync(tokenAddress: string, userAddress: string,
-                                       amountInBaseUnits: BigNumber): Promise<void> {
-        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
-        this.store.setBalance(tokenAddress, userAddress, balance.plus(amountInBaseUnits));
+    private async _increaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                        amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this._store.getBalanceAsync(tokenAddress, userAddress);
+        this._store.setBalance(tokenAddress, userAddress, balance.plus(amountInBaseUnits));
     }
-    private async decreaseBalanceAsync(tokenAddress: string, userAddress: string,
-                                       amountInBaseUnits: BigNumber): Promise<void> {
-        const balance = await this.store.getBalanceAsync(tokenAddress, userAddress);
-        this.store.setBalance(tokenAddress, userAddress, balance.minus(amountInBaseUnits));
+    private async _decreaseBalanceAsync(tokenAddress: string, userAddress: string,
+                                        amountInBaseUnits: BigNumber): Promise<void> {
+        const balance = await this._store.getBalanceAsync(tokenAddress, userAddress);
+        this._store.setBalance(tokenAddress, userAddress, balance.minus(amountInBaseUnits));
     }
 }
diff --git a/packages/0x.js/src/utils/order_state_utils.ts b/packages/0x.js/src/utils/order_state_utils.ts
index a0985d028..9849b073a 100644
--- a/packages/0x.js/src/utils/order_state_utils.ts
+++ b/packages/0x.js/src/utils/order_state_utils.ts
@@ -18,9 +18,9 @@ import {
 const ACCEPTABLE_RELATIVE_ROUNDING_ERROR = 0.0001;
 
 export class OrderStateUtils {
-    private balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
-    private orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
-    private static validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
+    private _balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore;
+    private _orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore;
+    private static _validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
         const unavailableTakerTokenAmount = orderRelevantState.cancelledTakerTokenAmount.add(
             orderRelevantState.filledTakerTokenAmount,
         );
@@ -53,14 +53,14 @@ export class OrderStateUtils {
     }
     constructor(balanceAndProxyAllowanceLazyStore: BalanceAndProxyAllowanceLazyStore,
                 orderFilledCancelledLazyStore: OrderFilledCancelledLazyStore) {
-        this.balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
-        this.orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
+        this._balanceAndProxyAllowanceLazyStore = balanceAndProxyAllowanceLazyStore;
+        this._orderFilledCancelledLazyStore = orderFilledCancelledLazyStore;
     }
     public async getOrderStateAsync(signedOrder: SignedOrder): Promise<OrderState> {
         const orderRelevantState = await this.getOrderRelevantStateAsync(signedOrder);
         const orderHash = ZeroEx.getOrderHashHex(signedOrder);
         try {
-            OrderStateUtils.validateIfOrderIsValid(signedOrder, orderRelevantState);
+            OrderStateUtils._validateIfOrderIsValid(signedOrder, orderRelevantState);
             const orderState: OrderStateValid = {
                 isValid: true,
                 orderHash,
@@ -81,23 +81,23 @@ export class OrderStateUtils {
         // If we pass it from the instantiator - there is no opportunity to get it there
         // because JS doesn't support async constructors.
         // Moreover - it's cached under the hood so it's equivalent to an async constructor.
-        const exchange = (this.orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
+        const exchange = (this._orderFilledCancelledLazyStore as any).exchange as ExchangeWrapper;
         const zrxTokenAddress = exchange.getZRXTokenAddress();
         const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-        const makerBalance = await this.balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+        const makerBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
             signedOrder.makerTokenAddress, signedOrder.maker,
         );
-        const makerProxyAllowance = await this.balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+        const makerProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
             signedOrder.makerTokenAddress, signedOrder.maker,
         );
-        const makerFeeBalance = await this.balanceAndProxyAllowanceLazyStore.getBalanceAsync(
+        const makerFeeBalance = await this._balanceAndProxyAllowanceLazyStore.getBalanceAsync(
             zrxTokenAddress, signedOrder.maker,
         );
-        const makerFeeProxyAllowance = await this.balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
+        const makerFeeProxyAllowance = await this._balanceAndProxyAllowanceLazyStore.getProxyAllowanceAsync(
             zrxTokenAddress, signedOrder.maker,
         );
-        const filledTakerTokenAmount = await this.orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
-        const cancelledTakerTokenAmount = await this.orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
+        const filledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getFilledTakerAmountAsync(orderHash);
+        const cancelledTakerTokenAmount = await this._orderFilledCancelledLazyStore.getCancelledTakerAmountAsync(
             orderHash,
         );
         const unavailableTakerTokenAmount = await exchange.getUnavailableTakerAmountAsync(orderHash);
diff --git a/packages/0x.js/src/utils/order_validation_utils.ts b/packages/0x.js/src/utils/order_validation_utils.ts
index 9185eef2b..ad82d85b4 100644
--- a/packages/0x.js/src/utils/order_validation_utils.ts
+++ b/packages/0x.js/src/utils/order_validation_utils.ts
@@ -10,7 +10,7 @@ import {utils} from '../utils/utils';
 import {ExchangeTransferSimulator} from './exchange_transfer_simulator';
 
 export class OrderValidationUtils {
-    private exchangeWrapper: ExchangeWrapper;
+    private _exchangeWrapper: ExchangeWrapper;
     public static validateCancelOrderThrowIfInvalid(
         order: Order, cancelTakerTokenAmount: BigNumber, unavailableTakerTokenAmount: BigNumber,
     ): void {
@@ -29,7 +29,7 @@ export class OrderValidationUtils {
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder,
         fillTakerTokenAmount: BigNumber, senderAddress: string, zrxTokenAddress: string,
     ): Promise<void> {
-        const fillMakerTokenAmount = OrderValidationUtils.getPartialAmount(
+        const fillMakerTokenAmount = OrderValidationUtils._getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerTokenAmount,
@@ -42,7 +42,7 @@ export class OrderValidationUtils {
             signedOrder.takerTokenAddress, senderAddress, signedOrder.maker, fillTakerTokenAmount,
             TradeSide.Taker, TransferType.Trade,
         );
-        const makerFeeAmount = OrderValidationUtils.getPartialAmount(
+        const makerFeeAmount = OrderValidationUtils._getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerFee,
@@ -51,7 +51,7 @@ export class OrderValidationUtils {
             zrxTokenAddress, signedOrder.maker, signedOrder.feeRecipient, makerFeeAmount, TradeSide.Maker,
             TransferType.Fee,
         );
-        const takerFeeAmount = OrderValidationUtils.getPartialAmount(
+        const takerFeeAmount = OrderValidationUtils._getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.takerFee,
@@ -61,21 +61,21 @@ export class OrderValidationUtils {
             TransferType.Fee,
         );
     }
-    private static validateRemainingFillAmountNotZeroOrThrow(
+    private static _validateRemainingFillAmountNotZeroOrThrow(
         takerTokenAmount: BigNumber, unavailableTakerTokenAmount: BigNumber,
     ) {
         if (takerTokenAmount.eq(unavailableTakerTokenAmount)) {
             throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
         }
     }
-    private static validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
+    private static _validateOrderNotExpiredOrThrow(expirationUnixTimestampSec: BigNumber) {
         const currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
         if (expirationUnixTimestampSec.lessThan(currentUnixTimestampSec)) {
             throw new Error(ExchangeContractErrs.OrderFillExpired);
         }
     }
-    private static getPartialAmount(numerator: BigNumber, denominator: BigNumber,
-                                    target: BigNumber): BigNumber {
+    private static _getPartialAmount(numerator: BigNumber, denominator: BigNumber,
+                                     target: BigNumber): BigNumber {
         const fillMakerTokenAmount = numerator
                                      .mul(target)
                                      .div(denominator)
@@ -83,22 +83,22 @@ export class OrderValidationUtils {
         return fillMakerTokenAmount;
     }
     constructor(exchangeWrapper: ExchangeWrapper) {
-        this.exchangeWrapper = exchangeWrapper;
+        this._exchangeWrapper = exchangeWrapper;
     }
     public async validateOrderFillableOrThrowAsync(
         exchangeTradeEmulator: ExchangeTransferSimulator, signedOrder: SignedOrder, zrxTokenAddress: string,
         expectedFillTakerTokenAmount?: BigNumber): Promise<void> {
         const orderHash = utils.getOrderHashHex(signedOrder);
-        const unavailableTakerTokenAmount = await this.exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils.validateRemainingFillAmountNotZeroOrThrow(
+        const unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(
             signedOrder.takerTokenAmount, unavailableTakerTokenAmount,
         );
-        OrderValidationUtils.validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
+        OrderValidationUtils._validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
         let fillTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
         if (!_.isUndefined(expectedFillTakerTokenAmount)) {
             fillTakerTokenAmount = expectedFillTakerTokenAmount;
         }
-        const fillMakerTokenAmount = OrderValidationUtils.getPartialAmount(
+        const fillMakerTokenAmount = OrderValidationUtils._getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerTokenAmount,
@@ -107,7 +107,7 @@ export class OrderValidationUtils {
             signedOrder.makerTokenAddress, signedOrder.maker, signedOrder.taker, fillMakerTokenAmount,
             TradeSide.Maker, TransferType.Trade,
         );
-        const makerFeeAmount = OrderValidationUtils.getPartialAmount(
+        const makerFeeAmount = OrderValidationUtils._getPartialAmount(
             fillTakerTokenAmount,
             signedOrder.takerTokenAmount,
             signedOrder.makerFee,
@@ -128,14 +128,14 @@ export class OrderValidationUtils {
         if (!ZeroEx.isValidSignature(orderHash, signedOrder.ecSignature, signedOrder.maker)) {
             throw new Error(ZeroExError.InvalidSignature);
         }
-        const unavailableTakerTokenAmount = await this.exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
-        OrderValidationUtils.validateRemainingFillAmountNotZeroOrThrow(
+        const unavailableTakerTokenAmount = await this._exchangeWrapper.getUnavailableTakerAmountAsync(orderHash);
+        OrderValidationUtils._validateRemainingFillAmountNotZeroOrThrow(
             signedOrder.takerTokenAmount, unavailableTakerTokenAmount,
         );
         if (signedOrder.taker !== constants.NULL_ADDRESS && signedOrder.taker !== takerAddress) {
             throw new Error(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
         }
-        OrderValidationUtils.validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
+        OrderValidationUtils._validateOrderNotExpiredOrThrow(signedOrder.expirationUnixTimestampSec);
         const remainingTakerTokenAmount = signedOrder.takerTokenAmount.minus(unavailableTakerTokenAmount);
         const filledTakerTokenAmount = remainingTakerTokenAmount.lessThan(fillTakerTokenAmount) ?
                                        remainingTakerTokenAmount :
@@ -144,7 +144,7 @@ export class OrderValidationUtils {
             exchangeTradeEmulator, signedOrder, filledTakerTokenAmount, takerAddress, zrxTokenAddress,
         );
 
-        const wouldRoundingErrorOccur = await this.exchangeWrapper.isRoundingErrorAsync(
+        const wouldRoundingErrorOccur = await this._exchangeWrapper.isRoundingErrorAsync(
             filledTakerTokenAmount, signedOrder.takerTokenAmount, signedOrder.makerTokenAmount,
         );
         if (wouldRoundingErrorOccur) {