Fix indentations

1 files changed, 151 insertions, 152 deletions

diff --git a/packages/contracts/util/exchange_wrapper.ts b/packages/contracts/util/exchange_wrapper.ts
index 062ea292b..304dcdacf 100644
--- a/packages/contracts/util/exchange_wrapper.ts
+++ b/packages/contracts/util/exchange_wrapper.ts
@@ -6,163 +6,162 @@ import {Order} from './order';
 import {ContractInstance} from './types';
 
 export class ExchangeWrapper {
-  private exchange: ContractInstance;
-  constructor(exchangeContractInstance: ContractInstance) {
-    this.exchange = exchangeContractInstance;
-  }
-  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(
-      params.orderAddresses,
-      params.orderValues,
-      params.fillTakerTokenAmount,
-      params.shouldThrowOnInsufficientBalanceOrAllowance,
-      params.v,
-      params.r,
-      params.s,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  public async cancelOrderAsync(order: Order, from: string,
-                                opts: {cancelTakerTokenAmount?: BigNumber} = {}) {
-    const params = order.createCancel(opts.cancelTakerTokenAmount);
-    const tx = await this.exchange.cancelOrder(
-      params.orderAddresses,
-      params.orderValues,
-      params.cancelTakerTokenAmount,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  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(
-      params.orderAddresses,
-      params.orderValues,
-      params.fillTakerTokenAmount,
-      params.v,
-      params.r,
-      params.s,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  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(
-      params.orderAddresses,
-      params.orderValues,
-      params.fillTakerTokenAmounts,
-      params.shouldThrowOnInsufficientBalanceOrAllowance,
-      params.v,
-      params.r,
-      params.s,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  public async batchFillOrKillOrdersAsync(orders: Order[], from: string,
-                                          opts: {
-                                              fillTakerTokenAmounts?: BigNumber[];
-                                          } = {}) {
-    const params = formatters.createBatchFill(orders, undefined, opts.fillTakerTokenAmounts);
-    const tx = await this.exchange.batchFillOrKillOrders(
-      params.orderAddresses,
-      params.orderValues,
-      params.fillTakerTokenAmounts,
-      params.v,
-      params.r,
-      params.s,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  public async fillOrdersUpToAsync(orders: Order[], from: string,
-                                   opts: {fillTakerTokenAmount?: BigNumber;
+    private exchange: ContractInstance;
+    constructor(exchangeContractInstance: ContractInstance) {
+        this.exchange = exchangeContractInstance;
+    }
+    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(
+            params.orderAddresses,
+            params.orderValues,
+            params.fillTakerTokenAmount,
+            params.shouldThrowOnInsufficientBalanceOrAllowance,
+            params.v,
+            params.r,
+            params.s,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    public async cancelOrderAsync(order: Order, from: string,
+                                  opts: {cancelTakerTokenAmount?: BigNumber} = {}) {
+        const params = order.createCancel(opts.cancelTakerTokenAmount);
+        const tx = await this.exchange.cancelOrder(
+            params.orderAddresses,
+            params.orderValues,
+            params.cancelTakerTokenAmount,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    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(
+            params.orderAddresses,
+            params.orderValues,
+            params.fillTakerTokenAmount,
+            params.v,
+            params.r,
+            params.s,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    public async batchFillOrdersAsync(orders: Order[], from: string,
+                                      opts: {
+                                          fillTakerTokenAmounts?: BigNumber[];
                                           shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
-                                   } = {}) {
-    const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
-    const params = formatters.createFillUpTo(orders,
+                                      } = {}) {
+        const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
+        const params = formatters.createBatchFill(
+                orders, shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts);
+        const tx = await this.exchange.batchFillOrders(
+            params.orderAddresses,
+            params.orderValues,
+            params.fillTakerTokenAmounts,
+            params.shouldThrowOnInsufficientBalanceOrAllowance,
+            params.v,
+            params.r,
+            params.s,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    public async batchFillOrKillOrdersAsync(orders: Order[], from: string,
+                                            opts: {fillTakerTokenAmounts?: BigNumber[]} = {}) {
+        const params = formatters.createBatchFill(orders, undefined, opts.fillTakerTokenAmounts);
+        const tx = await this.exchange.batchFillOrKillOrders(
+            params.orderAddresses,
+            params.orderValues,
+            params.fillTakerTokenAmounts,
+            params.v,
+            params.r,
+            params.s,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    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(
-      params.orderAddresses,
-      params.orderValues,
-      params.fillTakerTokenAmount,
-      params.shouldThrowOnInsufficientBalanceOrAllowance,
-      params.v,
-      params.r,
-      params.s,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  public async batchCancelOrdersAsync(orders: Order[], from: string,
-                                      opts: {cancelTakerTokenAmounts?: BigNumber[]} = {}) {
-    const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
-    const tx = await this.exchange.batchCancelOrders(
-      params.orderAddresses,
-      params.orderValues,
-      params.cancelTakerTokenAmounts,
-      {from},
-    );
-    _.each(tx.logs, log => wrapLogBigNumbers(log));
-    return tx;
-  }
-  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);
-    return orderHash;
-  }
-  public async isValidSignatureAsync(order: Order): Promise<boolean> {
-    const isValidSignature = await this.exchange.isValidSignature(
-      order.params.maker,
-      order.params.orderHashHex,
-      order.params.v,
-      order.params.r,
-      order.params.s,
-    );
-    return isValidSignature;
-  }
-  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));
-    return partialAmount;
-  }
+        const tx = await this.exchange.fillOrdersUpTo(
+            params.orderAddresses,
+            params.orderValues,
+            params.fillTakerTokenAmount,
+            params.shouldThrowOnInsufficientBalanceOrAllowance,
+            params.v,
+            params.r,
+            params.s,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    public async batchCancelOrdersAsync(orders: Order[], from: string,
+                                        opts: {cancelTakerTokenAmounts?: BigNumber[]} = {}) {
+        const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
+        const tx = await this.exchange.batchCancelOrders(
+            params.orderAddresses,
+            params.orderValues,
+            params.cancelTakerTokenAmounts,
+            {from},
+        );
+        _.each(tx.logs, log => wrapLogBigNumbers(log));
+        return tx;
+    }
+    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);
+        return orderHash;
+    }
+    public async isValidSignatureAsync(order: Order): Promise<boolean> {
+        const isValidSignature = await this.exchange.isValidSignature(
+            order.params.maker,
+            order.params.orderHashHex,
+            order.params.v,
+            order.params.r,
+            order.params.s,
+        );
+        return isValidSignature;
+    }
+    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));
+        return partialAmount;
+    }
 }
 
 function wrapLogBigNumbers(log: any): any {
-  const argNames = _.keys(log.args);
-  for (const argName of argNames) {
-    const isWeb3BigNumber = _.startsWith(log.args[argName].constructor.toString(), 'function BigNumber(');
-    if (isWeb3BigNumber) {
-      log.args[argName] = new BigNumber(log.args[argName]);
+    const argNames = _.keys(log.args);
+    for (const argName of argNames) {
+        const isWeb3BigNumber = _.startsWith(log.args[argName].constructor.toString(), 'function BigNumber(');
+        if (isWeb3BigNumber) {
+            log.args[argName] = new BigNumber(log.args[argName]);
+        }
     }
-  }
 }