1 files changed, 79 insertions, 55 deletions
diff --git a/packages/contracts/util/exchange_wrapper.ts b/packages/contracts/util/exchange_wrapper.ts
index 304dcdacf..ca79f92c4 100644
--- a/packages/contracts/util/exchange_wrapper.ts
+++ b/packages/contracts/util/exchange_wrapper.ts
@@ -1,23 +1,26 @@
-import {BigNumber} from 'bignumber.js';
+import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
-import {formatters} from './formatters';
-import {Order} from './order';
-import {ContractInstance} from './types';
+import { formatters } from './formatters';
+import { Order } from './order';
+import { ContractInstance } from './types';
 
 export class ExchangeWrapper {
-    private exchange: ContractInstance;
+    private _exchange: ContractInstance;
     constructor(exchangeContractInstance: ContractInstance) {
-        this.exchange = exchangeContractInstance;
+        this._exchange = exchangeContractInstance;
     }
-    public async fillOrderAsync(order: Order, from: string,
-                                opts: {
-                                    fillTakerTokenAmount?: BigNumber;
-                                    shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
-                                } = {}) {
+    public async fillOrderAsync(
+        order: Order,
+        from: string,
+        opts: {
+            fillTakerTokenAmount?: BigNumber;
+            shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
+        } = {},
+    ) {
         const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
         const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
-        const tx = await this.exchange.fillOrder(
+        const tx = await this._exchange.fillOrder(
             params.orderAddresses,
             params.orderValues,
             params.fillTakerTokenAmount,
@@ -25,48 +28,52 @@ export class ExchangeWrapper {
             params.v,
             params.r,
             params.s,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async cancelOrderAsync(order: Order, from: string,
-                                  opts: {cancelTakerTokenAmount?: BigNumber} = {}) {
+    public async cancelOrderAsync(order: Order, from: string, opts: { cancelTakerTokenAmount?: BigNumber } = {}) {
         const params = order.createCancel(opts.cancelTakerTokenAmount);
-        const tx = await this.exchange.cancelOrder(
+        const tx = await this._exchange.cancelOrder(
             params.orderAddresses,
             params.orderValues,
             params.cancelTakerTokenAmount,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async fillOrKillOrderAsync(order: Order, from: string,
-                                      opts: {fillTakerTokenAmount?: BigNumber} = {}) {
+    public async fillOrKillOrderAsync(order: Order, from: string, opts: { fillTakerTokenAmount?: BigNumber } = {}) {
         const shouldThrowOnInsufficientBalanceOrAllowance = true;
         const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
-        const tx = await this.exchange.fillOrKillOrder(
+        const tx = await this._exchange.fillOrKillOrder(
             params.orderAddresses,
             params.orderValues,
             params.fillTakerTokenAmount,
             params.v,
             params.r,
             params.s,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async batchFillOrdersAsync(orders: Order[], from: string,
-                                      opts: {
-                                          fillTakerTokenAmounts?: BigNumber[];
-                                          shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
-                                      } = {}) {
+    public async batchFillOrdersAsync(
+        orders: Order[],
+        from: string,
+        opts: {
+            fillTakerTokenAmounts?: BigNumber[];
+            shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
+        } = {},
+    ) {
         const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
         const params = formatters.createBatchFill(
-                orders, shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts);
-        const tx = await this.exchange.batchFillOrders(
+            orders,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            opts.fillTakerTokenAmounts,
+        );
+        const tx = await this._exchange.batchFillOrders(
             params.orderAddresses,
             params.orderValues,
             params.fillTakerTokenAmounts,
@@ -74,36 +81,44 @@ export class ExchangeWrapper {
             params.v,
             params.r,
             params.s,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async batchFillOrKillOrdersAsync(orders: Order[], from: string,
-                                            opts: {fillTakerTokenAmounts?: BigNumber[]} = {}) {
+    public async batchFillOrKillOrdersAsync(
+        orders: Order[],
+        from: string,
+        opts: { fillTakerTokenAmounts?: BigNumber[] } = {},
+    ) {
         const params = formatters.createBatchFill(orders, undefined, opts.fillTakerTokenAmounts);
-        const tx = await this.exchange.batchFillOrKillOrders(
+        const tx = await this._exchange.batchFillOrKillOrders(
             params.orderAddresses,
             params.orderValues,
             params.fillTakerTokenAmounts,
             params.v,
             params.r,
             params.s,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async fillOrdersUpToAsync(orders: Order[], from: string,
-                                     opts: {
-                                        fillTakerTokenAmount?: BigNumber;
-                                        shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
-                                     } = {}) {
+    public async fillOrdersUpToAsync(
+        orders: Order[],
+        from: string,
+        opts: {
+            fillTakerTokenAmount?: BigNumber;
+            shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
+        } = {},
+    ) {
         const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
-        const params = formatters.createFillUpTo(orders,
-                                             shouldThrowOnInsufficientBalanceOrAllowance,
-                                             opts.fillTakerTokenAmount);
-        const tx = await this.exchange.fillOrdersUpTo(
+        const params = formatters.createFillUpTo(
+            orders,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            opts.fillTakerTokenAmount,
+        );
+        const tx = await this._exchange.fillOrdersUpTo(
             params.orderAddresses,
             params.orderValues,
             params.fillTakerTokenAmount,
@@ -111,19 +126,22 @@ export class ExchangeWrapper {
             params.v,
             params.r,
             params.s,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
     }
-    public async batchCancelOrdersAsync(orders: Order[], from: string,
-                                        opts: {cancelTakerTokenAmounts?: BigNumber[]} = {}) {
+    public async batchCancelOrdersAsync(
+        orders: Order[],
+        from: string,
+        opts: { cancelTakerTokenAmounts?: BigNumber[] } = {},
+    ) {
         const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
-        const tx = await this.exchange.batchCancelOrders(
+        const tx = await this._exchange.batchCancelOrders(
             params.orderAddresses,
             params.orderValues,
             params.cancelTakerTokenAmounts,
-            {from},
+            { from },
         );
         _.each(tx.logs, log => wrapLogBigNumbers(log));
         return tx;
@@ -131,11 +149,11 @@ export class ExchangeWrapper {
     public async getOrderHashAsync(order: Order): Promise<string> {
         const shouldThrowOnInsufficientBalanceOrAllowance = false;
         const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance);
-        const orderHash = await this.exchange.getOrderHash(params.orderAddresses, params.orderValues);
+        const orderHash = await this._exchange.getOrderHash(params.orderAddresses, params.orderValues);
         return orderHash;
     }
     public async isValidSignatureAsync(order: Order): Promise<boolean> {
-        const isValidSignature = await this.exchange.isValidSignature(
+        const isValidSignature = await this._exchange.isValidSignature(
             order.params.maker,
             order.params.orderHashHex,
             order.params.v,
@@ -144,14 +162,20 @@ export class ExchangeWrapper {
         );
         return isValidSignature;
     }
-    public async isRoundingErrorAsync(numerator: BigNumber, denominator: BigNumber,
-                                      target: BigNumber): Promise<boolean> {
-        const isRoundingError = await this.exchange.isRoundingError(numerator, denominator, target);
+    public async isRoundingErrorAsync(
+        numerator: BigNumber,
+        denominator: BigNumber,
+        target: BigNumber,
+    ): Promise<boolean> {
+        const isRoundingError = await this._exchange.isRoundingError(numerator, denominator, target);
         return isRoundingError;
     }
-    public async getPartialAmountAsync(numerator: BigNumber, denominator: BigNumber,
-                                       target: BigNumber): Promise<BigNumber> {
-        const partialAmount = new BigNumber(await this.exchange.getPartialAmount(numerator, denominator, target));
+    public async getPartialAmountAsync(
+        numerator: BigNumber,
+        denominator: BigNumber,
+        target: BigNumber,
+    ): Promise<BigNumber> {
+        const partialAmount = new BigNumber(await this._exchange.getPartialAmount(numerator, denominator, target));
         return partialAmount;
     }
 }