1 files changed, 28 insertions, 28 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);
         }
     }