Merge branch 'v2-prototype' into bug/contracts/eip712-191-prefix

19 files changed, 277 insertions, 65 deletions

diff --git a/packages/contracts/src/utils/artifacts.ts b/packages/contracts/src/utils/artifacts.ts
index 357c66a0a..bf7221d6d 100644
--- a/packages/contracts/src/utils/artifacts.ts
+++ b/packages/contracts/src/utils/artifacts.ts
@@ -2,6 +2,7 @@ import { ContractArtifact } from '@0xproject/sol-compiler';
 
 import * as AssetProxyOwner from '../artifacts/AssetProxyOwner.json';
 import * as DummyERC20Token from '../artifacts/DummyERC20Token.json';
+import * as DummyERC721Receiver from '../artifacts/DummyERC721Receiver.json';
 import * as DummyERC721Token from '../artifacts/DummyERC721Token.json';
 import * as ERC20Proxy from '../artifacts/ERC20Proxy.json';
 import * as ERC721Proxy from '../artifacts/ERC721Proxy.json';
@@ -9,8 +10,10 @@ import * as Exchange from '../artifacts/Exchange.json';
 import * as MixinAuthorizable from '../artifacts/MixinAuthorizable.json';
 import * as MultiSigWallet from '../artifacts/MultiSigWallet.json';
 import * as MultiSigWalletWithTimeLock from '../artifacts/MultiSigWalletWithTimeLock.json';
+import * as TestAssetDataDecoders from '../artifacts/TestAssetDataDecoders.json';
 import * as TestAssetProxyDispatcher from '../artifacts/TestAssetProxyDispatcher.json';
 import * as TestLibBytes from '../artifacts/TestLibBytes.json';
+import * as TestLibMem from '../artifacts/TestLibMem.json';
 import * as TestLibs from '../artifacts/TestLibs.json';
 import * as TestSignatureValidator from '../artifacts/TestSignatureValidator.json';
 import * as TokenRegistry from '../artifacts/TokenRegistry.json';
@@ -21,6 +24,7 @@ import * as ZRX from '../artifacts/ZRXToken.json';
 export const artifacts = {
     AssetProxyOwner: (AssetProxyOwner as any) as ContractArtifact,
     DummyERC20Token: (DummyERC20Token as any) as ContractArtifact,
+    DummyERC721Receiver: (DummyERC721Receiver as any) as ContractArtifact,
     DummyERC721Token: (DummyERC721Token as any) as ContractArtifact,
     ERC20Proxy: (ERC20Proxy as any) as ContractArtifact,
     ERC721Proxy: (ERC721Proxy as any) as ContractArtifact,
@@ -30,7 +34,9 @@ export const artifacts = {
     MultiSigWallet: (MultiSigWallet as any) as ContractArtifact,
     MultiSigWalletWithTimeLock: (MultiSigWalletWithTimeLock as any) as ContractArtifact,
     TestAssetProxyDispatcher: (TestAssetProxyDispatcher as any) as ContractArtifact,
+    TestAssetDataDecoders: (TestAssetDataDecoders as any) as ContractArtifact,
     TestLibBytes: (TestLibBytes as any) as ContractArtifact,
+    TestLibMem: (TestLibMem as any) as ContractArtifact,
     TestLibs: (TestLibs as any) as ContractArtifact,
     TestSignatureValidator: (TestSignatureValidator as any) as ContractArtifact,
     TokenRegistry: (TokenRegistry as any) as ContractArtifact,
diff --git a/packages/contracts/src/utils/assertions.ts b/packages/contracts/src/utils/assertions.ts
new file mode 100644
index 000000000..615e648f3
--- /dev/null
+++ b/packages/contracts/src/utils/assertions.ts
@@ -0,0 +1,63 @@
+import * as chai from 'chai';
+import * as _ from 'lodash';
+
+import { constants } from './constants';
+
+const expect = chai.expect;
+
+function _expectEitherErrorAsync<T>(p: Promise<T>, error1: string, error2: string): PromiseLike<void> {
+    return expect(p)
+        .to.be.rejected()
+        .then(e => {
+            expect(e).to.satisfy(
+                (err: Error) => _.includes(err.message, error1) || _.includes(err.message, error2),
+                `expected promise to reject with error message that includes "${error1}" or "${error2}", but got: ` +
+                    `"${e.message}"\n`,
+            );
+        });
+}
+
+/**
+ * Rejects if the given Promise does not reject with an error indicating
+ * insufficient funds.
+ * @param p the Promise which is expected to reject
+ * @returns a new Promise which will reject if the conditions are not met and
+ * otherwise resolve with no value.
+ */
+export function expectInsufficientFundsAsync<T>(p: Promise<T>): PromiseLike<void> {
+    return _expectEitherErrorAsync(p, 'insufficient funds', "sender doesn't have enough funds");
+}
+
+/**
+ * Rejects if the given Promise does not reject with a "revert" error or the
+ * given otherError.
+ * @param p the Promise which is expected to reject
+ * @param otherError the other error which is accepted as a valid reject error.
+ * @returns a new Promise which will reject if the conditions are not met and
+ * otherwise resolve with no value.
+ */
+export function expectRevertOrOtherErrorAsync<T>(p: Promise<T>, otherError: string): PromiseLike<void> {
+    return _expectEitherErrorAsync(p, constants.REVERT, otherError);
+}
+
+/**
+ * Rejects if the given Promise does not reject with a "revert" or "always
+ * failing transaction" error.
+ * @param p the Promise which is expected to reject
+ * @returns a new Promise which will reject if the conditions are not met and
+ * otherwise resolve with no value.
+ */
+export function expectRevertOrAlwaysFailingTransactionAsync<T>(p: Promise<T>): PromiseLike<void> {
+    return expectRevertOrOtherErrorAsync(p, 'always failing transaction');
+}
+
+/**
+ * Rejects if the given Promise does not reject with a "revert" or "Contract
+ * call failed" error.
+ * @param p the Promise which is expected to reject
+ * @returns a new Promise which will reject if the conditions are not met and
+ * otherwise resolve with no value.
+ */
+export function expectRevertOrContractCallFailedAsync<T>(p: Promise<T>): PromiseLike<void> {
+    return expectRevertOrOtherErrorAsync<T>(p, 'Contract call failed');
+}
diff --git a/packages/contracts/src/utils/constants.ts b/packages/contracts/src/utils/constants.ts
index 9b0b92545..ec3c8fd36 100644
--- a/packages/contracts/src/utils/constants.ts
+++ b/packages/contracts/src/utils/constants.ts
@@ -19,8 +19,19 @@ const TESTRPC_PRIVATE_KEYS_STRINGS = [
 export const constants = {
     INVALID_OPCODE: 'invalid opcode',
     REVERT: 'revert',
+    LIB_BYTES_GREATER_THAN_ZERO_LENGTH_REQUIRED: 'GREATER_THAN_ZERO_LENGTH_REQUIRED',
+    LIB_BYTES_GREATER_OR_EQUAL_TO_4_LENGTH_REQUIRED: 'GREATER_OR_EQUAL_TO_4_LENGTH_REQUIRED',
+    LIB_BYTES_GREATER_OR_EQUAL_TO_20_LENGTH_REQUIRED: 'GREATER_OR_EQUAL_TO_20_LENGTH_REQUIRED',
+    LIB_BYTES_GREATER_OR_EQUAL_TO_32_LENGTH_REQUIRED: 'GREATER_OR_EQUAL_TO_32_LENGTH_REQUIRED',
+    LIB_BYTES_GREATER_OR_EQUAL_TO_NESTED_BYTES_LENGTH_REQUIRED: 'GREATER_OR_EQUAL_TO_NESTED_BYTES_LENGTH_REQUIRED',
+    LIB_BYTES_GREATER_OR_EQUAL_TO_SOURCE_BYTES_LENGTH_REQUIRED: 'GREATER_OR_EQUAL_TO_SOURCE_BYTES_LENGTH_REQUIRED',
+    ERC20_INSUFFICIENT_BALANCE: 'Insufficient balance to complete transfer.',
+    ERC20_INSUFFICIENT_ALLOWANCE: 'Insufficient allowance to complete transfer.',
     TESTRPC_NETWORK_ID: 50,
-    AWAIT_TRANSACTION_MINED_MS: 100,
+    // Note(albrow): In practice V8 and most other engines limit the minimum
+    // interval for setInterval to 10ms. We still set it to 0 here in order to
+    // ensure we always use the minimum interval.
+    AWAIT_TRANSACTION_MINED_MS: 0,
     MAX_ETHERTOKEN_WITHDRAW_GAS: 43000,
     MAX_TOKEN_TRANSFERFROM_GAS: 80000,
     MAX_TOKEN_APPROVE_GAS: 60000,
diff --git a/packages/contracts/src/utils/coverage.ts b/packages/contracts/src/utils/coverage.ts
index a37939464..de29a3ecc 100644
--- a/packages/contracts/src/utils/coverage.ts
+++ b/packages/contracts/src/utils/coverage.ts
@@ -1,6 +1,5 @@
 import { devConstants } from '@0xproject/dev-utils';
 import { CoverageSubprovider, SolCompilerArtifactAdapter } from '@0xproject/sol-cov';
-import * as fs from 'fs';
 import * as _ from 'lodash';
 
 let coverageSubprovider: CoverageSubprovider;
@@ -15,7 +14,8 @@ export const coverage = {
     _getCoverageSubprovider(): CoverageSubprovider {
         const defaultFromAddress = devConstants.TESTRPC_FIRST_ADDRESS;
         const solCompilerArtifactAdapter = new SolCompilerArtifactAdapter();
-        const subprovider = new CoverageSubprovider(solCompilerArtifactAdapter, defaultFromAddress);
+        const isVerbose = true;
+        const subprovider = new CoverageSubprovider(solCompilerArtifactAdapter, defaultFromAddress, isVerbose);
         return subprovider;
     },
 };
diff --git a/packages/contracts/src/utils/erc20_wrapper.ts b/packages/contracts/src/utils/erc20_wrapper.ts
index dceeceeea..91c9d50b7 100644
--- a/packages/contracts/src/utils/erc20_wrapper.ts
+++ b/packages/contracts/src/utils/erc20_wrapper.ts
@@ -3,8 +3,8 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Provider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { DummyERC20TokenContract } from '../contract_wrappers/generated/dummy_e_r_c20_token';
-import { ERC20ProxyContract } from '../contract_wrappers/generated/e_r_c20_proxy';
+import { DummyERC20TokenContract } from '../generated_contract_wrappers/dummy_e_r_c20_token';
+import { ERC20ProxyContract } from '../generated_contract_wrappers/e_r_c20_proxy';
 
 import { artifacts } from './artifacts';
 import { constants } from './constants';
diff --git a/packages/contracts/src/utils/erc721_wrapper.ts b/packages/contracts/src/utils/erc721_wrapper.ts
index 13fdf630e..b20d9acd2 100644
--- a/packages/contracts/src/utils/erc721_wrapper.ts
+++ b/packages/contracts/src/utils/erc721_wrapper.ts
@@ -4,8 +4,8 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Provider } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { DummyERC721TokenContract } from '../contract_wrappers/generated/dummy_e_r_c721_token';
-import { ERC721ProxyContract } from '../contract_wrappers/generated/e_r_c721_proxy';
+import { DummyERC721TokenContract } from '../generated_contract_wrappers/dummy_e_r_c721_token';
+import { ERC721ProxyContract } from '../generated_contract_wrappers/e_r_c721_proxy';
 
 import { artifacts } from './artifacts';
 import { constants } from './constants';
diff --git a/packages/contracts/src/utils/exchange_wrapper.ts b/packages/contracts/src/utils/exchange_wrapper.ts
index dd278e77c..4cc8f0b89 100644
--- a/packages/contracts/src/utils/exchange_wrapper.ts
+++ b/packages/contracts/src/utils/exchange_wrapper.ts
@@ -1,10 +1,10 @@
 import { AssetProxyId, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import { LogEntry, Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
+import { Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { ExchangeContract } from '../contract_wrappers/generated/exchange';
+import { ExchangeContract } from '../generated_contract_wrappers/exchange';
 
 import { constants } from './constants';
 import { formatters } from './formatters';
@@ -60,14 +60,14 @@ export class ExchangeWrapper {
     public async fillOrderNoThrowAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerAssetFillAmount?: BigNumber } = {},
+        opts: { takerAssetFillAmount?: BigNumber; gas?: number } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
         const txHash = await this._exchange.fillOrderNoThrow.sendTransactionAsync(
             params.order,
             params.takerAssetFillAmount,
             params.signature,
-            { from },
+            { from, gas: opts.gas },
         );
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
@@ -105,14 +105,14 @@ export class ExchangeWrapper {
     public async batchFillOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerAssetFillAmounts?: BigNumber[] } = {},
+        opts: { takerAssetFillAmounts?: BigNumber[]; gas?: number } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
         const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync(
             params.orders,
             params.takerAssetFillAmounts,
             params.signatures,
-            { from },
+            { from, gas: opts.gas },
         );
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
@@ -135,14 +135,14 @@ export class ExchangeWrapper {
     public async marketSellOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerAssetFillAmount: BigNumber },
+        opts: { takerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount);
         const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync(
             params.orders,
             params.takerAssetFillAmount,
             params.signatures,
-            { from },
+            { from, gas: opts.gas },
         );
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
@@ -165,14 +165,14 @@ export class ExchangeWrapper {
     public async marketBuyOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { makerAssetFillAmount: BigNumber },
+        opts: { makerAssetFillAmount: BigNumber; gas?: number },
     ): Promise<TransactionReceiptWithDecodedLogs> {
         const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount);
         const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync(
             params.orders,
             params.makerAssetFillAmount,
             params.signatures,
-            { from },
+            { from, gas: opts.gas },
         );
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
diff --git a/packages/contracts/src/utils/formatters.ts b/packages/contracts/src/utils/formatters.ts
index 1035f2d7c..32e4787d6 100644
--- a/packages/contracts/src/utils/formatters.ts
+++ b/packages/contracts/src/utils/formatters.ts
@@ -2,6 +2,7 @@ import { SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
+import { constants } from './constants';
 import { orderUtils } from './order_utils';
 import { BatchCancelOrders, BatchFillOrders, MarketBuyOrders, MarketSellOrders } from './types';
 
@@ -28,8 +29,11 @@ export const formatters = {
             signatures: [],
             takerAssetFillAmount,
         };
-        _.forEach(signedOrders, signedOrder => {
+        _.forEach(signedOrders, (signedOrder, i) => {
             const orderWithoutExchangeAddress = orderUtils.getOrderWithoutExchangeAddress(signedOrder);
+            if (i !== 0) {
+                orderWithoutExchangeAddress.takerAssetData = constants.NULL_BYTES;
+            }
             marketSellOrders.orders.push(orderWithoutExchangeAddress);
             marketSellOrders.signatures.push(signedOrder.signature);
         });
@@ -41,8 +45,11 @@ export const formatters = {
             signatures: [],
             makerAssetFillAmount,
         };
-        _.forEach(signedOrders, signedOrder => {
+        _.forEach(signedOrders, (signedOrder, i) => {
             const orderWithoutExchangeAddress = orderUtils.getOrderWithoutExchangeAddress(signedOrder);
+            if (i !== 0) {
+                orderWithoutExchangeAddress.makerAssetData = constants.NULL_BYTES;
+            }
             marketBuyOrders.orders.push(orderWithoutExchangeAddress);
             marketBuyOrders.signatures.push(signedOrder.signature);
         });
diff --git a/packages/contracts/src/utils/increase_time.ts b/packages/contracts/src/utils/increase_time.ts
new file mode 100644
index 000000000..4565d8dbc
--- /dev/null
+++ b/packages/contracts/src/utils/increase_time.ts
@@ -0,0 +1,31 @@
+import * as _ from 'lodash';
+
+import { constants } from './constants';
+import { web3Wrapper } from './web3_wrapper';
+
+let firstAccount: string | undefined;
+
+/**
+ * Increases time by the given number of seconds and then mines a block so that
+ * the current block timestamp has the offset applied.
+ * @param seconds the number of seconds by which to incrase the time offset.
+ * @returns a new Promise which will resolve with the new total time offset or
+ * reject if the time could not be increased.
+ */
+export async function increaseTimeAndMineBlockAsync(seconds: number): Promise<number> {
+    if (_.isUndefined(firstAccount)) {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        firstAccount = accounts[0];
+    }
+
+    const offset = await web3Wrapper.increaseTimeAsync(seconds);
+    // Note: we need to send a transaction after increasing time so
+    // that a block is actually mined. The contract looks at the
+    // last mined block for the timestamp.
+    await web3Wrapper.awaitTransactionSuccessAsync(
+        await web3Wrapper.sendTransactionAsync({ from: firstAccount, to: firstAccount, value: 0 }),
+        constants.AWAIT_TRANSACTION_MINED_MS,
+    );
+
+    return offset;
+}
diff --git a/packages/contracts/src/utils/log_decoder.ts b/packages/contracts/src/utils/log_decoder.ts
index 07d10e69d..07127ba79 100644
--- a/packages/contracts/src/utils/log_decoder.ts
+++ b/packages/contracts/src/utils/log_decoder.ts
@@ -39,6 +39,7 @@ export class LogDecoder {
     }
     public decodeLogOrThrow<ArgsType extends DecodedLogArgs>(log: LogEntry): LogWithDecodedArgs<ArgsType> | RawLog {
         const logWithDecodedArgsOrLog = this._abiDecoder.tryToDecodeLogOrNoop(log);
+        // tslint:disable-next-line:no-unnecessary-type-assertion
         if (_.isUndefined((logWithDecodedArgsOrLog as LogWithDecodedArgs<ArgsType>).args)) {
             throw new Error(`Unable to decode log: ${JSON.stringify(log)}`);
         }
diff --git a/packages/contracts/src/utils/match_order_tester.ts b/packages/contracts/src/utils/match_order_tester.ts
index 6170188bc..fbb1b99db 100644
--- a/packages/contracts/src/utils/match_order_tester.ts
+++ b/packages/contracts/src/utils/match_order_tester.ts
@@ -1,38 +1,21 @@
-import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { assetProxyUtils, crypto, orderHashUtils } from '@0xproject/order-utils';
+import { assetProxyUtils, orderHashUtils } from '@0xproject/order-utils';
 import { AssetProxyId, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
-import { LogWithDecodedArgs } from 'ethereum-types';
-import ethUtil = require('ethereumjs-util');
 import * as _ from 'lodash';
 
-import { DummyERC20TokenContract } from '../contract_wrappers/generated/dummy_e_r_c20_token';
-import { DummyERC721TokenContract } from '../contract_wrappers/generated/dummy_e_r_c721_token';
-import { ERC20ProxyContract } from '../contract_wrappers/generated/e_r_c20_proxy';
-import { ERC721ProxyContract } from '../contract_wrappers/generated/e_r_c721_proxy';
-import {
-    CancelContractEventArgs,
-    ExchangeContract,
-    FillContractEventArgs,
-} from '../contract_wrappers/generated/exchange';
 import { chaiSetup } from '../utils/chai_setup';
-import { constants } from '../utils/constants';
 import { ERC20Wrapper } from '../utils/erc20_wrapper';
 import { ERC721Wrapper } from '../utils/erc721_wrapper';
 import { ExchangeWrapper } from '../utils/exchange_wrapper';
-import { OrderFactory } from '../utils/order_factory';
 import {
-    ContractName,
     ERC20BalancesByOwner,
     ERC721TokenIdsByOwner,
     TransferAmountsByMatchOrders as TransferAmounts,
 } from '../utils/types';
-import { provider, web3Wrapper } from '../utils/web3_wrapper';
 
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 export class MatchOrderTester {
     private _exchangeWrapper: ExchangeWrapper;
@@ -112,11 +95,6 @@ export class MatchOrderTester {
         initialTakerAssetFilledAmountLeft?: BigNumber,
         initialTakerAssetFilledAmountRight?: BigNumber,
     ): Promise<[ERC20BalancesByOwner, ERC721TokenIdsByOwner]> {
-        // Test setup & verify preconditions
-        const makerAddressLeft = signedOrderLeft.makerAddress;
-        const makerAddressRight = signedOrderRight.makerAddress;
-        const feeRecipientAddressLeft = signedOrderLeft.feeRecipientAddress;
-        const feeRecipientAddressRight = signedOrderRight.feeRecipientAddress;
         // Verify Left order preconditions
         const orderTakerAssetFilledAmountLeft = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
             orderHashUtils.getOrderHashHex(signedOrderLeft),
@@ -259,11 +237,11 @@ export class MatchOrderTester {
         const expectedNewERC20BalancesByOwner = _.cloneDeep(erc20BalancesByOwner);
         const expectedNewERC721TokenIdsByOwner = _.cloneDeep(erc721TokenIdsByOwner);
         // Left Maker Asset (Right Taker Asset)
-        const makerAssetProxyIdLeft = assetProxyUtils.decodeProxyDataId(signedOrderLeft.makerAssetData);
+        const makerAssetProxyIdLeft = assetProxyUtils.decodeAssetDataId(signedOrderLeft.makerAssetData);
         if (makerAssetProxyIdLeft === AssetProxyId.ERC20) {
             // Decode asset data
-            const erc20ProxyData = assetProxyUtils.decodeERC20ProxyData(signedOrderLeft.makerAssetData);
-            const makerAssetAddressLeft = erc20ProxyData.tokenAddress;
+            const erc20AssetData = assetProxyUtils.decodeERC20AssetData(signedOrderLeft.makerAssetData);
+            const makerAssetAddressLeft = erc20AssetData.tokenAddress;
             const takerAssetAddressRight = makerAssetAddressLeft;
             // Left Maker
             expectedNewERC20BalancesByOwner[makerAddressLeft][makerAssetAddressLeft] = expectedNewERC20BalancesByOwner[
@@ -281,9 +259,9 @@ export class MatchOrderTester {
             ][makerAssetAddressLeft].add(expectedTransferAmounts.amountReceivedByTaker);
         } else if (makerAssetProxyIdLeft === AssetProxyId.ERC721) {
             // Decode asset data
-            const erc721ProxyData = assetProxyUtils.decodeERC721ProxyData(signedOrderLeft.makerAssetData);
-            const makerAssetAddressLeft = erc721ProxyData.tokenAddress;
-            const makerAssetIdLeft = erc721ProxyData.tokenId;
+            const erc721AssetData = assetProxyUtils.decodeERC721AssetData(signedOrderLeft.makerAssetData);
+            const makerAssetAddressLeft = erc721AssetData.tokenAddress;
+            const makerAssetIdLeft = erc721AssetData.tokenId;
             const takerAssetAddressRight = makerAssetAddressLeft;
             const takerAssetIdRight = makerAssetIdLeft;
             // Left Maker
@@ -294,11 +272,11 @@ export class MatchOrderTester {
         }
         // Left Taker Asset (Right Maker Asset)
         // Note: This exchange is only between the order makers: the Taker does not receive any of the left taker asset.
-        const takerAssetProxyIdLeft = assetProxyUtils.decodeProxyDataId(signedOrderLeft.takerAssetData);
+        const takerAssetProxyIdLeft = assetProxyUtils.decodeAssetDataId(signedOrderLeft.takerAssetData);
         if (takerAssetProxyIdLeft === AssetProxyId.ERC20) {
             // Decode asset data
-            const erc20ProxyData = assetProxyUtils.decodeERC20ProxyData(signedOrderLeft.takerAssetData);
-            const takerAssetAddressLeft = erc20ProxyData.tokenAddress;
+            const erc20AssetData = assetProxyUtils.decodeERC20AssetData(signedOrderLeft.takerAssetData);
+            const takerAssetAddressLeft = erc20AssetData.tokenAddress;
             const makerAssetAddressRight = takerAssetAddressLeft;
             // Left Maker
             expectedNewERC20BalancesByOwner[makerAddressLeft][takerAssetAddressLeft] = expectedNewERC20BalancesByOwner[
@@ -312,9 +290,9 @@ export class MatchOrderTester {
             );
         } else if (takerAssetProxyIdLeft === AssetProxyId.ERC721) {
             // Decode asset data
-            const erc721ProxyData = assetProxyUtils.decodeERC721ProxyData(signedOrderRight.makerAssetData);
-            const makerAssetAddressRight = erc721ProxyData.tokenAddress;
-            const makerAssetIdRight = erc721ProxyData.tokenId;
+            const erc721AssetData = assetProxyUtils.decodeERC721AssetData(signedOrderRight.makerAssetData);
+            const makerAssetAddressRight = erc721AssetData.tokenAddress;
+            const makerAssetIdRight = erc721AssetData.tokenId;
             const takerAssetAddressLeft = makerAssetAddressRight;
             const takerAssetIdLeft = makerAssetIdRight;
             // Right Maker
diff --git a/packages/contracts/src/utils/multi_sig_wrapper.ts b/packages/contracts/src/utils/multi_sig_wrapper.ts
index 9971e8f6e..f0098bd5e 100644
--- a/packages/contracts/src/utils/multi_sig_wrapper.ts
+++ b/packages/contracts/src/utils/multi_sig_wrapper.ts
@@ -3,10 +3,9 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
-import { AssetProxyOwnerContract } from '../contract_wrappers/generated/asset_proxy_owner';
-import { MultiSigWalletContract } from '../contract_wrappers/generated/multi_sig_wallet';
+import { AssetProxyOwnerContract } from '../generated_contract_wrappers/asset_proxy_owner';
+import { MultiSigWalletContract } from '../generated_contract_wrappers/multi_sig_wallet';
 
-import { constants } from './constants';
 import { LogDecoder } from './log_decoder';
 
 export class MultiSigWrapper {
@@ -45,6 +44,7 @@ export class MultiSigWrapper {
         txId: BigNumber,
         from: string,
     ): Promise<TransactionReceiptWithDecodedLogs> {
+        // tslint:disable-next-line:no-unnecessary-type-assertion
         const txHash = await (this
             ._multiSig as AssetProxyOwnerContract).executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from });
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
diff --git a/packages/contracts/src/utils/order_factory.ts b/packages/contracts/src/utils/order_factory.ts
index dd02e1f5c..009dbc396 100644
--- a/packages/contracts/src/utils/order_factory.ts
+++ b/packages/contracts/src/utils/order_factory.ts
@@ -1,7 +1,6 @@
 import { generatePseudoRandomSalt, orderHashUtils } from '@0xproject/order-utils';
 import { Order, SignatureType, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
 
 import { constants } from './constants';
 import { signingUtils } from './signing_utils';
diff --git a/packages/contracts/src/utils/order_utils.ts b/packages/contracts/src/utils/order_utils.ts
index 180761f2c..a9f994d80 100644
--- a/packages/contracts/src/utils/order_utils.ts
+++ b/packages/contracts/src/utils/order_utils.ts
@@ -1,7 +1,7 @@
 import { OrderWithoutExchangeAddress, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
-import ethUtil = require('ethereumjs-util');
 
+import { constants } from './constants';
 import { CancelOrder, MatchOrder } from './types';
 
 export const orderUtils = {
@@ -44,6 +44,8 @@ export const orderUtils = {
             leftSignature: signedOrderLeft.signature,
             rightSignature: signedOrderRight.signature,
         };
+        fill.right.makerAssetData = constants.NULL_BYTES;
+        fill.right.takerAssetData = constants.NULL_BYTES;
         return fill;
     },
 };
diff --git a/packages/contracts/src/utils/profiler.ts b/packages/contracts/src/utils/profiler.ts
new file mode 100644
index 000000000..85ee24f22
--- /dev/null
+++ b/packages/contracts/src/utils/profiler.ts
@@ -0,0 +1,27 @@
+import { devConstants } from '@0xproject/dev-utils';
+import { ProfilerSubprovider, SolCompilerArtifactAdapter } from '@0xproject/sol-cov';
+import * as _ from 'lodash';
+
+let profilerSubprovider: ProfilerSubprovider;
+
+export const profiler = {
+    start(): void {
+        profiler.getProfilerSubproviderSingleton().start();
+    },
+    stop(): void {
+        profiler.getProfilerSubproviderSingleton().stop();
+    },
+    getProfilerSubproviderSingleton(): ProfilerSubprovider {
+        if (_.isUndefined(profilerSubprovider)) {
+            profilerSubprovider = profiler._getProfilerSubprovider();
+        }
+        return profilerSubprovider;
+    },
+    _getProfilerSubprovider(): ProfilerSubprovider {
+        const defaultFromAddress = devConstants.TESTRPC_FIRST_ADDRESS;
+        const solCompilerArtifactAdapter = new SolCompilerArtifactAdapter();
+        const isVerbose = true;
+        const subprovider = new ProfilerSubprovider(solCompilerArtifactAdapter, defaultFromAddress, isVerbose);
+        return subprovider;
+    },
+};
diff --git a/packages/contracts/src/utils/revert_trace.ts b/packages/contracts/src/utils/revert_trace.ts
new file mode 100644
index 000000000..0bf8384bc
--- /dev/null
+++ b/packages/contracts/src/utils/revert_trace.ts
@@ -0,0 +1,21 @@
+import { devConstants } from '@0xproject/dev-utils';
+import { RevertTraceSubprovider, SolCompilerArtifactAdapter } from '@0xproject/sol-cov';
+import * as _ from 'lodash';
+
+let revertTraceSubprovider: RevertTraceSubprovider;
+
+export const revertTrace = {
+    getRevertTraceSubproviderSingleton(): RevertTraceSubprovider {
+        if (_.isUndefined(revertTraceSubprovider)) {
+            revertTraceSubprovider = revertTrace._getRevertTraceSubprovider();
+        }
+        return revertTraceSubprovider;
+    },
+    _getRevertTraceSubprovider(): RevertTraceSubprovider {
+        const defaultFromAddress = devConstants.TESTRPC_FIRST_ADDRESS;
+        const solCompilerArtifactAdapter = new SolCompilerArtifactAdapter();
+        const isVerbose = true;
+        const subprovider = new RevertTraceSubprovider(solCompilerArtifactAdapter, defaultFromAddress, isVerbose);
+        return subprovider;
+    },
+};
diff --git a/packages/contracts/src/utils/token_registry_wrapper.ts b/packages/contracts/src/utils/token_registry_wrapper.ts
index 240c06fdc..91895aa59 100644
--- a/packages/contracts/src/utils/token_registry_wrapper.ts
+++ b/packages/contracts/src/utils/token_registry_wrapper.ts
@@ -1,7 +1,7 @@
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Provider } from 'ethereum-types';
 
-import { TokenRegistryContract } from '../contract_wrappers/generated/token_registry';
+import { TokenRegistryContract } from '../generated_contract_wrappers/token_registry';
 
 import { Token } from './types';
 
diff --git a/packages/contracts/src/utils/types.ts b/packages/contracts/src/utils/types.ts
index 360e1fdbc..bb8c12088 100644
--- a/packages/contracts/src/utils/types.ts
+++ b/packages/contracts/src/utils/types.ts
@@ -1,6 +1,6 @@
-import { Order, OrderWithoutExchangeAddress } from '@0xproject/types';
+import { OrderWithoutExchangeAddress } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
-import { AbiDefinition, ContractAbi } from 'ethereum-types';
+import { AbiDefinition } from 'ethereum-types';
 
 export interface ERC20BalancesByOwner {
     [ownerAddress: string]: {
@@ -90,11 +90,14 @@ export enum ContractName {
     AccountLevels = 'AccountLevels',
     EtherDelta = 'EtherDelta',
     Arbitrage = 'Arbitrage',
+    TestAssetDataDecoders = 'TestAssetDataDecoders',
     TestAssetProxyDispatcher = 'TestAssetProxyDispatcher',
+    TestLibMem = 'TestLibMem',
     TestLibs = 'TestLibs',
     TestSignatureValidator = 'TestSignatureValidator',
     ERC20Proxy = 'ERC20Proxy',
     ERC721Proxy = 'ERC721Proxy',
+    DummyERC721Receiver = 'DummyERC721Receiver',
     DummyERC721Token = 'DummyERC721Token',
     TestLibBytes = 'TestLibBytes',
     Authorizable = 'Authorizable',
diff --git a/packages/contracts/src/utils/web3_wrapper.ts b/packages/contracts/src/utils/web3_wrapper.ts
index 1049ab967..c9d83a02d 100644
--- a/packages/contracts/src/utils/web3_wrapper.ts
+++ b/packages/contracts/src/utils/web3_wrapper.ts
@@ -1,19 +1,82 @@
 import { devConstants, env, EnvVars, web3Factory } from '@0xproject/dev-utils';
 import { prependSubprovider } from '@0xproject/subproviders';
+import { logUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import { Provider } from 'ethereum-types';
+import * as _ from 'lodash';
 
 import { coverage } from './coverage';
+import { profiler } from './profiler';
+import { revertTrace } from './revert_trace';
 
-export const txDefaults = {
+enum ProviderType {
+    Ganache = 'ganache',
+    Geth = 'geth',
+}
+
+let testProvider: ProviderType;
+switch (process.env.TEST_PROVIDER) {
+    case undefined:
+        testProvider = ProviderType.Ganache;
+        break;
+    case 'ganache':
+        testProvider = ProviderType.Ganache;
+        break;
+    case 'geth':
+        testProvider = ProviderType.Geth;
+        break;
+    default:
+        throw new Error(`Unknown TEST_PROVIDER: ${process.env.TEST_PROVIDER}`);
+}
+
+const ganacheTxDefaults = {
     from: devConstants.TESTRPC_FIRST_ADDRESS,
     gas: devConstants.GAS_LIMIT,
 };
-const providerConfigs = { shouldUseInProcessGanache: true };
+const gethTxDefaults = {
+    from: devConstants.TESTRPC_FIRST_ADDRESS,
+};
+export const txDefaults = testProvider === ProviderType.Ganache ? ganacheTxDefaults : gethTxDefaults;
+
+const gethConfigs = {
+    shouldUseInProcessGanache: false,
+    rpcUrl: 'http://localhost:8501',
+    shouldUseFakeGasEstimate: false,
+};
+const ganacheConfigs = {
+    shouldUseInProcessGanache: true,
+};
+const providerConfigs = testProvider === ProviderType.Ganache ? ganacheConfigs : gethConfigs;
+
 export const provider = web3Factory.getRpcProvider(providerConfigs);
 const isCoverageEnabled = env.parseBoolean(EnvVars.SolidityCoverage);
+const isProfilerEnabled = env.parseBoolean(EnvVars.SolidityProfiler);
+const isRevertTraceEnabled = env.parseBoolean(EnvVars.SolidityRevertTrace);
+const enabledSubproviderCount = _.filter([isCoverageEnabled, isProfilerEnabled, isRevertTraceEnabled], _.identity)
+    .length;
+if (enabledSubproviderCount > 1) {
+    throw new Error(`Only one of coverage, profiler, or revert trace subproviders can be enabled at a time`);
+}
 if (isCoverageEnabled) {
     const coverageSubprovider = coverage.getCoverageSubproviderSingleton();
     prependSubprovider(provider, coverageSubprovider);
 }
+if (isProfilerEnabled) {
+    if (testProvider === ProviderType.Ganache) {
+        logUtils.warn(
+            "Gas costs in Ganache traces are incorrect and we don't recommend using it for profiling. Please switch to Geth",
+        );
+        process.exit(1);
+    }
+    const profilerSubprovider = profiler.getProfilerSubproviderSingleton();
+    logUtils.log(
+        "By default profilerSubprovider is stopped so that you don't get noise from setup code. Don't forget to start it before the code you want to profile and stop it afterwards",
+    );
+    profilerSubprovider.stop();
+    prependSubprovider(provider, profilerSubprovider);
+}
+if (isRevertTraceEnabled) {
+    const revertTraceSubprovider = revertTrace.getRevertTraceSubproviderSingleton();
+    prependSubprovider(provider, revertTraceSubprovider);
+}
+
 export const web3Wrapper = new Web3Wrapper(provider);