@0x/contracts-exchange: Remove log decoding in ExchangeWrapper test class in favor of awaitTransactionSuccessAsync.

contracts/exchange/test/utils/exchange_wrapper.ts

@@ -1,7 +1,4 @@
-import { artifacts as erc1155Artifacts } from '@0x/contracts-erc1155';
-import { artifacts as erc20Artifacts } from '@0x/contracts-erc20';
-import { artifacts as erc721Artifacts } from '@0x/contracts-erc721';
-import { BatchMatchOrder, LogDecoder, orderUtils, Web3ProviderEngine } from '@0x/contracts-test-utils';
+import { BatchMatchOrder, orderUtils, Web3ProviderEngine } from '@0x/contracts-test-utils';
 import {
     BatchMatchedFillResults,
     FillResults,
@@ -11,28 +8,18 @@ import {
     SignedZeroExTransaction,
 } from '@0x/types';
 import { AbiEncoder, BigNumber } from '@0x/utils';
-import { Web3Wrapper } from '@0x/web3-wrapper';
 import { MethodAbi, TransactionReceiptWithDecodedLogs, ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { artifacts, ExchangeContract } from '../../src';
+import { ExchangeContract } from '../../src';
 
 import { AbiDecodedFillOrderData } from './types';
 
 export class ExchangeWrapper {
     private readonly _exchange: ExchangeContract;
     // tslint:disable no-unused-variable
-    private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _logDecoder: LogDecoder;
     constructor(exchangeContract: ExchangeContract, provider: Web3ProviderEngine | ZeroExProvider) {
         this._exchange = exchangeContract;
-        this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, {
-            ...artifacts,
-            ...erc20Artifacts,
-            ...erc721Artifacts,
-            ...erc1155Artifacts,
-        });
     }
     public async fillOrderAsync(
         signedOrder: SignedOrder,
@@ -86,7 +73,7 @@ export class ExchangeWrapper {
         from: string,
         opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchFillOrders.sendTransactionAsync(
+        return this._exchange.batchFillOrders.awaitTransactionSuccessAsync(
             orders,
             opts.takerAssetFillAmounts === undefined
                 ? orders.map(signedOrder => signedOrder.takerAssetAmount)
@@ -94,15 +81,13 @@ export class ExchangeWrapper {
             orders.map(signedOrder => signedOrder.signature),
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchFillOrKillOrdersAsync(
         orders: SignedOrder[],
         from: string,
         opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync(
+        return this._exchange.batchFillOrKillOrders.awaitTransactionSuccessAsync(
             orders,
             opts.takerAssetFillAmounts === undefined
                 ? orders.map(signedOrder => signedOrder.takerAssetAmount)
@@ -110,15 +95,13 @@ export class ExchangeWrapper {
             orders.map(signedOrder => signedOrder.signature),
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchFillOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
         opts: { takerAssetFillAmounts?: BigNumber[]; gas?: number } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync(
+        return this._exchange.batchFillOrdersNoThrow.awaitTransactionSuccessAsync(
             orders,
             opts.takerAssetFillAmounts === undefined
                 ? orders.map(signedOrder => signedOrder.takerAssetAmount)
@@ -126,72 +109,60 @@ export class ExchangeWrapper {
             orders.map(signedOrder => signedOrder.signature),
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async marketSellOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
         opts: { takerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync(
+        return this._exchange.marketSellOrdersNoThrow.awaitTransactionSuccessAsync(
             orders,
             opts.takerAssetFillAmount,
             orders.map(signedOrder => signedOrder.signature),
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async marketBuyOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
         opts: { makerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync(
+        return this._exchange.marketBuyOrdersNoThrow.awaitTransactionSuccessAsync(
             orders,
             opts.makerAssetFillAmount,
             orders.map(signedOrder => signedOrder.signature),
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async marketSellOrdersFillOrKillAsync(
         orders: SignedOrder[],
         from: string,
         opts: { takerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.marketSellOrdersFillOrKill.sendTransactionAsync(
+        return this._exchange.marketSellOrdersFillOrKill.awaitTransactionSuccessAsync(
             orders,
             opts.takerAssetFillAmount,
             orders.map(signedOrder => signedOrder.signature),
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async marketBuyOrdersFillOrKillAsync(
         orders: SignedOrder[],
         from: string,
         opts: { makerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.marketBuyOrdersFillOrKill.sendTransactionAsync(
+        return this._exchange.marketBuyOrdersFillOrKill.awaitTransactionSuccessAsync(
             orders,
             opts.makerAssetFillAmount,
             orders.map(signedOrder => signedOrder.signature),
             { from, gas: opts.gas },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchCancelOrdersAsync(
         orders: SignedOrder[],
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchCancelOrders.sendTransactionAsync(orders, { from });
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return this._exchange.batchCancelOrders.awaitTransactionSuccessAsync(orders, { from });
     }
     public async cancelOrdersUpToAsync(salt: BigNumber, from: string): Promise<TransactionReceiptWithDecodedLogs> {
         const txReceipt = await this._exchange.cancelOrdersUpTo.awaitTransactionSuccessAsync(salt, { from });
@@ -210,28 +181,22 @@ export class ExchangeWrapper {
         signedTransaction: SignedZeroExTransaction,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.executeTransaction.sendTransactionAsync(
+        return this._exchange.executeTransaction.awaitTransactionSuccessAsync(
             signedTransaction,
             signedTransaction.signature,
             {
                 from,
             },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchExecuteTransactionsAsync(
         signedTransactions: SignedZeroExTransaction[],
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const signatures = signedTransactions.map(signedTransaction => signedTransaction.signature);
-        const txHash = await this._exchange.batchExecuteTransactions.sendTransactionAsync(
-            signedTransactions,
-            signatures,
-            { from },
-        );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
+        return this._exchange.batchExecuteTransactions.awaitTransactionSuccessAsync(signedTransactions, signatures, {
+            from,
+        });
     }
     public async getTakerAssetFilledAmountAsync(orderHashHex: string): Promise<BigNumber> {
         const filledAmount = await this._exchange.filled.callAsync(orderHashHex);
@@ -259,29 +224,25 @@ export class ExchangeWrapper {
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createBatchMatchOrders(signedOrdersLeft, signedOrdersRight);
-        const txHash = await this._exchange.batchMatchOrders.sendTransactionAsync(
+        return this._exchange.batchMatchOrders.awaitTransactionSuccessAsync(
             params.leftOrders,
             params.rightOrders,
             params.leftSignatures,
             params.rightSignatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchMatchOrdersRawAsync(
         params: BatchMatchOrder,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchMatchOrders.sendTransactionAsync(
+        return this._exchange.batchMatchOrders.awaitTransactionSuccessAsync(
             params.leftOrders,
             params.rightOrders,
             params.leftSignatures,
             params.rightSignatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async getBatchMatchOrdersResultsAsync(
         signedOrdersLeft: SignedOrder[],
@@ -304,29 +265,25 @@ export class ExchangeWrapper {
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createBatchMatchOrders(signedOrdersLeft, signedOrdersRight);
-        const txHash = await this._exchange.batchMatchOrdersWithMaximalFill.sendTransactionAsync(
+        return this._exchange.batchMatchOrdersWithMaximalFill.awaitTransactionSuccessAsync(
             params.leftOrders,
             params.rightOrders,
             params.leftSignatures,
             params.rightSignatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async batchMatchOrdersWithMaximalFillRawAsync(
         params: BatchMatchOrder,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const txHash = await this._exchange.batchMatchOrdersWithMaximalFill.sendTransactionAsync(
+        return this._exchange.batchMatchOrdersWithMaximalFill.awaitTransactionSuccessAsync(
             params.leftOrders,
             params.rightOrders,
             params.leftSignatures,
             params.rightSignatures,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async getBatchMatchOrdersWithMaximalFillResultsAsync(
         signedOrdersLeft: SignedOrder[],
@@ -379,15 +336,13 @@ export class ExchangeWrapper {
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createMatchOrders(signedOrderLeft, signedOrderRight);
-        const txHash = await this._exchange.matchOrdersWithMaximalFill.sendTransactionAsync(
+        return this._exchange.matchOrdersWithMaximalFill.awaitTransactionSuccessAsync(
             params.left,
             params.right,
             params.leftSignature,
             params.rightSignature,
             { from },
         );
-        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
-        return tx;
     }
     public async getMatchOrdersWithMaximalFillResultsAsync(
         signedOrderLeft: SignedOrder,