Merge branch 'development'

* development: (939 commits)
  Add asset-buyer to published packages section in README
  Publish
  Updated CHANGELOGS
  Update BuyQuote interface
  force re-build
  Add website build to instructions
  Revert format and re-add changes
  Build website in parallel with other tests since no other test relies on it being built to run
  Add back sourceMap support for both dev/prod
  Upgrade webpack
  Add missing default options
  Remove unused constants
  Add fee order with a takerFee
  Add additional order factory methods and refactor test to use them
  Add comments about buy quote calculation
  Update CHANGELOG
  Fix linter
  Add additional test for slippage
  Add buy_quote_calculator_test
  Add 0x Instant to bundle analysis
  ...

37 files changed, 3678 insertions, 669 deletions

diff --git a/packages/contracts/test/asset_proxy/authorizable.ts b/packages/contracts/test/asset_proxy/authorizable.ts
index e99c6cee3..0c0da46b3 100644
--- a/packages/contracts/test/asset_proxy/authorizable.ts
+++ b/packages/contracts/test/asset_proxy/authorizable.ts
@@ -2,6 +2,7 @@ import { BlockchainLifecycle } from '@0xproject/dev-utils';
 import { RevertReason } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
+import * as _ from 'lodash';
 
 import { MixinAuthorizableContract } from '../../generated_contract_wrappers/mixin_authorizable';
 import { artifacts } from '../utils/artifacts';
@@ -28,8 +29,7 @@ describe('Authorizable', () => {
     });
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
-        owner = address = accounts[0];
-        notOwner = accounts[1];
+        [owner, address, notOwner] = _.slice(accounts, 0, 3);
         authorizable = await MixinAuthorizableContract.deployFrom0xArtifactAsync(
             artifacts.MixinAuthorizable,
             provider,
diff --git a/packages/contracts/test/asset_proxy/proxies.ts b/packages/contracts/test/asset_proxy/proxies.ts
index 62215f08d..4d70031d1 100644
--- a/packages/contracts/test/asset_proxy/proxies.ts
+++ b/packages/contracts/test/asset_proxy/proxies.ts
@@ -8,11 +8,13 @@ import * as _ from 'lodash';
 import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
 import { DummyERC721ReceiverContract } from '../../generated_contract_wrappers/dummy_erc721_receiver';
 import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_erc721_token';
+import { DummyMultipleReturnERC20TokenContract } from '../../generated_contract_wrappers/dummy_multiple_return_erc20_token';
+import { DummyNoReturnERC20TokenContract } from '../../generated_contract_wrappers/dummy_no_return_erc20_token';
 import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
 import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
 import { IAssetProxyContract } from '../../generated_contract_wrappers/i_asset_proxy';
 import { artifacts } from '../utils/artifacts';
-import { expectTransactionFailedAsync } from '../utils/assertions';
+import { expectTransactionFailedAsync, expectTransactionFailedWithoutReasonAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { ERC20Wrapper } from '../utils/erc20_wrapper';
@@ -42,6 +44,8 @@ describe('Asset Transfer Proxies', () => {
     let erc721Receiver: DummyERC721ReceiverContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
+    let noReturnErc20Token: DummyNoReturnERC20TokenContract;
+    let multipleReturnErc20Token: DummyMultipleReturnERC20TokenContract;
 
     let erc20Wrapper: ERC20Wrapper;
     let erc721Wrapper: ERC721Wrapper;
@@ -91,6 +95,51 @@ describe('Asset Transfer Proxies', () => {
             provider,
             txDefaults,
         );
+        noReturnErc20Token = await DummyNoReturnERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.DummyNoReturnERC20Token,
+            provider,
+            txDefaults,
+            constants.DUMMY_TOKEN_NAME,
+            constants.DUMMY_TOKEN_SYMBOL,
+            constants.DUMMY_TOKEN_DECIMALS,
+            constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+        );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await noReturnErc20Token.setBalance.sendTransactionAsync(makerAddress, constants.INITIAL_ERC20_BALANCE),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await noReturnErc20Token.approve.sendTransactionAsync(
+                erc20Proxy.address,
+                constants.INITIAL_ERC20_ALLOWANCE,
+                { from: makerAddress },
+            ),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+        multipleReturnErc20Token = await DummyMultipleReturnERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.DummyMultipleReturnERC20Token,
+            provider,
+            txDefaults,
+            constants.DUMMY_TOKEN_NAME,
+            constants.DUMMY_TOKEN_SYMBOL,
+            constants.DUMMY_TOKEN_DECIMALS,
+            constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+        );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await multipleReturnErc20Token.setBalance.sendTransactionAsync(
+                makerAddress,
+                constants.INITIAL_ERC20_BALANCE,
+            ),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await multipleReturnErc20Token.approve.sendTransactionAsync(
+                erc20Proxy.address,
+                constants.INITIAL_ERC20_ALLOWANCE,
+                { from: makerAddress },
+            ),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -99,6 +148,17 @@ describe('Asset Transfer Proxies', () => {
         await blockchainLifecycle.revertAsync();
     });
     describe('Transfer Proxy - ERC20', () => {
+        it('should revert if undefined function is called', async () => {
+            const undefinedSelector = '0x01020304';
+            await expectTransactionFailedWithoutReasonAsync(
+                web3Wrapper.sendTransactionAsync({
+                    from: owner,
+                    to: erc20Proxy.address,
+                    value: constants.ZERO_AMOUNT,
+                    data: undefinedSelector,
+                }),
+            );
+        });
         describe('transferFrom', () => {
             it('should successfully transfer tokens', async () => {
                 // Construct ERC20 asset data
@@ -130,6 +190,65 @@ describe('Asset Transfer Proxies', () => {
                 );
             });
 
+            it('should successfully transfer tokens that do not return a value', async () => {
+                // Construct ERC20 asset data
+                const encodedAssetData = assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address);
+                // Perform a transfer from makerAddress to takerAddress
+                const initialMakerBalance = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const initialTakerBalance = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+                const amount = new BigNumber(10);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: erc20Proxy.address,
+                        data,
+                        from: exchangeAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // Verify transfer was successful
+                const newMakerBalance = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const newTakerBalance = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+                expect(newMakerBalance).to.be.bignumber.equal(initialMakerBalance.minus(amount));
+                expect(newTakerBalance).to.be.bignumber.equal(initialTakerBalance.plus(amount));
+            });
+
+            it('should successfully transfer tokens and ignore extra assetData', async () => {
+                // Construct ERC20 asset data
+                const extraData = '0102030405060708';
+                const encodedAssetData = `${assetDataUtils.encodeERC20AssetData(zrxToken.address)}${extraData}`;
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(10);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: erc20Proxy.address,
+                        data,
+                        from: exchangeAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // Verify transfer was successful
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[makerAddress][zrxToken.address].minus(amount),
+                );
+                expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[takerAddress][zrxToken.address].add(amount),
+                );
+            });
+
             it('should do nothing if transferring 0 amount of a token', async () => {
                 // Construct ERC20 asset data
                 const encodedAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
@@ -178,6 +297,7 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     constants.AWAIT_TRANSACTION_MINED_MS,
                 );
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
                 // Perform a transfer; expect this to fail.
                 await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
@@ -187,6 +307,43 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.TransferFailed,
                 );
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                expect(newBalances).to.deep.equal(erc20Balances);
+            });
+
+            it('should throw if allowances are too low and token does not return a value', async () => {
+                // Construct ERC20 asset data
+                const encodedAssetData = assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address);
+                // Create allowance less than transfer amount. Set allowance on proxy.
+                const allowance = new BigNumber(0);
+                const amount = new BigNumber(10);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await noReturnErc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const initialMakerBalance = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const initialTakerBalance = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+                // Perform a transfer; expect this to fail.
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: erc20Proxy.address,
+                        data,
+                        from: exchangeAddress,
+                    }),
+                    RevertReason.TransferFailed,
+                );
+                const newMakerBalance = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const newTakerBalance = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+                expect(newMakerBalance).to.be.bignumber.equal(initialMakerBalance);
+                expect(newTakerBalance).to.be.bignumber.equal(initialTakerBalance);
             });
 
             it('should throw if requesting address is not authorized', async () => {
@@ -200,6 +357,7 @@ describe('Asset Transfer Proxies', () => {
                     takerAddress,
                     amount,
                 );
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
                 await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
                         to: erc20Proxy.address,
@@ -208,6 +366,35 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.SenderNotAuthorized,
                 );
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                expect(newBalances).to.deep.equal(erc20Balances);
+            });
+
+            it('should throw if token returns more than 32 bytes', async () => {
+                // Construct ERC20 asset data
+                const encodedAssetData = assetDataUtils.encodeERC20AssetData(multipleReturnErc20Token.address);
+                const amount = new BigNumber(10);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                );
+                const initialMakerBalance = await multipleReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const initialTakerBalance = await multipleReturnErc20Token.balanceOf.callAsync(takerAddress);
+                // Perform a transfer; expect this to fail.
+                await expectTransactionFailedAsync(
+                    web3Wrapper.sendTransactionAsync({
+                        to: erc20Proxy.address,
+                        data,
+                        from: exchangeAddress,
+                    }),
+                    RevertReason.TransferFailed,
+                );
+                const newMakerBalance = await multipleReturnErc20Token.balanceOf.callAsync(makerAddress);
+                const newTakerBalance = await multipleReturnErc20Token.balanceOf.callAsync(takerAddress);
+                expect(newMakerBalance).to.be.bignumber.equal(initialMakerBalance);
+                expect(newTakerBalance).to.be.bignumber.equal(initialTakerBalance);
             });
         });
 
@@ -219,13 +406,55 @@ describe('Asset Transfer Proxies', () => {
     });
 
     describe('Transfer Proxy - ERC721', () => {
+        it('should revert if undefined function is called', async () => {
+            const undefinedSelector = '0x01020304';
+            await expectTransactionFailedWithoutReasonAsync(
+                web3Wrapper.sendTransactionAsync({
+                    from: owner,
+                    to: erc721Proxy.address,
+                    value: constants.ZERO_AMOUNT,
+                    data: undefinedSelector,
+                }),
+            );
+        });
         describe('transferFrom', () => {
             it('should successfully transfer tokens', async () => {
                 // Construct ERC721 asset data
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
                 // Verify pre-condition
                 const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
+                // Perform a transfer from makerAddress to takerAddress
+                const amount = new BigNumber(1);
+                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await web3Wrapper.sendTransactionAsync({
+                        to: erc721Proxy.address,
+                        data,
+                        from: exchangeAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                // Verify transfer was successful
+                const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwnerMakerAsset).to.be.bignumber.equal(takerAddress);
+            });
+
+            it('should successfully transfer tokens and ignore extra assetData', async () => {
+                // Construct ERC721 asset data
+                const extraData = '0102030405060708';
+                const encodedAssetData = `${assetDataUtils.encodeERC721AssetData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                )}${extraData}`;
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Perform a transfer from makerAddress to takerAddress
                 const amount = new BigNumber(1);
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@@ -252,7 +481,7 @@ describe('Asset Transfer Proxies', () => {
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
                 // Verify pre-condition
                 const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Perform a transfer from makerAddress to takerAddress
                 const amount = new BigNumber(1);
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@@ -261,7 +490,7 @@ describe('Asset Transfer Proxies', () => {
                     erc721Receiver.address,
                     amount,
                 );
-                const logDecoder = new LogDecoder(web3Wrapper, erc721Receiver.address);
+                const logDecoder = new LogDecoder(web3Wrapper);
                 const tx = await logDecoder.getTxWithDecodedLogsAsync(
                     await web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
@@ -271,7 +500,7 @@ describe('Asset Transfer Proxies', () => {
                     }),
                 );
                 // Verify that no log was emitted by erc721 receiver
-                expect(tx.logs.length).to.be.equal(0);
+                expect(tx.logs.length).to.be.equal(1);
                 // Verify transfer was successful
                 const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
                 expect(newOwnerMakerAsset).to.be.bignumber.equal(erc721Receiver.address);
@@ -282,7 +511,7 @@ describe('Asset Transfer Proxies', () => {
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
                 // Verify pre-condition
                 const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Perform a transfer from makerAddress to takerAddress
                 const amount = new BigNumber(0);
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@@ -291,7 +520,7 @@ describe('Asset Transfer Proxies', () => {
                     takerAddress,
                     amount,
                 );
-                return expectTransactionFailedAsync(
+                await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
                         data,
@@ -299,6 +528,8 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.InvalidAmount,
                 );
+                const newOwner = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwner).to.be.equal(ownerMakerAsset);
             });
 
             it('should throw if transferring > 1 amount of a token', async () => {
@@ -306,7 +537,7 @@ describe('Asset Transfer Proxies', () => {
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
                 // Verify pre-condition
                 const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Perform a transfer from makerAddress to takerAddress
                 const amount = new BigNumber(500);
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@@ -315,7 +546,7 @@ describe('Asset Transfer Proxies', () => {
                     takerAddress,
                     amount,
                 );
-                return expectTransactionFailedAsync(
+                await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
                         data,
@@ -323,11 +554,16 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.InvalidAmount,
                 );
+                const newOwner = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwner).to.be.equal(ownerMakerAsset);
             });
 
             it('should throw if allowances are too low', async () => {
                 // Construct ERC721 asset data
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Remove transfer approval for makerAddress.
                 await web3Wrapper.awaitTransactionSuccessAsync(
                     await erc721Token.approve.sendTransactionAsync(constants.NULL_ADDRESS, erc721MakerTokenId, {
@@ -343,7 +579,7 @@ describe('Asset Transfer Proxies', () => {
                     takerAddress,
                     amount,
                 );
-                return expectTransactionFailedAsync(
+                await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
                         data,
@@ -351,11 +587,16 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.TransferFailed,
                 );
+                const newOwner = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwner).to.be.equal(ownerMakerAsset);
             });
 
             it('should throw if requesting address is not authorized', async () => {
                 // Construct ERC721 asset data
                 const encodedAssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, erc721MakerTokenId);
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.equal(makerAddress);
                 // Perform a transfer from makerAddress to takerAddress
                 const amount = new BigNumber(1);
                 const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
@@ -364,7 +605,7 @@ describe('Asset Transfer Proxies', () => {
                     takerAddress,
                     amount,
                 );
-                return expectTransactionFailedAsync(
+                await expectTransactionFailedAsync(
                     web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
                         data,
@@ -372,6 +613,8 @@ describe('Asset Transfer Proxies', () => {
                     }),
                     RevertReason.SenderNotAuthorized,
                 );
+                const newOwner = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwner).to.be.equal(ownerMakerAsset);
             });
         });
 
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index b324988cc..acb99eed1 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -1,6 +1,6 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
 import { assetDataUtils, orderHashUtils } from '@0xproject/order-utils';
-import { RevertReason, SignedOrder } from '@0xproject/types';
+import { RevertReason, SignatureType, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
@@ -8,11 +8,17 @@ import { LogWithDecodedArgs } from 'ethereum-types';
 import ethUtil = require('ethereumjs-util');
 import * as _ from 'lodash';
 
-import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
+import {
+    DummyERC20TokenContract,
+    DummyERC20TokenTransferEventArgs,
+} from '../../generated_contract_wrappers/dummy_erc20_token';
 import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_erc721_token';
+import { DummyNoReturnERC20TokenContract } from '../../generated_contract_wrappers/dummy_no_return_erc20_token';
 import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
 import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
 import { ExchangeCancelEventArgs, ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { ReentrantERC20TokenContract } from '../../generated_contract_wrappers/reentrant_erc20_token';
+import { TestStaticCallReceiverContract } from '../../generated_contract_wrappers/test_static_call_receiver';
 import { artifacts } from '../utils/artifacts';
 import { expectTransactionFailedAsync } from '../utils/assertions';
 import { getLatestBlockTimestampAsync, increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
@@ -39,9 +45,13 @@ describe('Exchange core', () => {
     let erc20TokenB: DummyERC20TokenContract;
     let zrxToken: DummyERC20TokenContract;
     let erc721Token: DummyERC721TokenContract;
+    let noReturnErc20Token: DummyNoReturnERC20TokenContract;
+    let reentrantErc20Token: ReentrantERC20TokenContract;
     let exchange: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
+    let maliciousWallet: TestStaticCallReceiverContract;
+    let maliciousValidator: TestStaticCallReceiverContract;
 
     let signedOrder: SignedOrder;
     let erc20Balances: ERC20BalancesByOwner;
@@ -107,6 +117,18 @@ describe('Exchange core', () => {
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
+        maliciousWallet = maliciousValidator = await TestStaticCallReceiverContract.deployFrom0xArtifactAsync(
+            artifacts.TestStaticCallReceiver,
+            provider,
+            txDefaults,
+        );
+        reentrantErc20Token = await ReentrantERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.ReentrantERC20Token,
+            provider,
+            txDefaults,
+            exchange.address,
+        );
+
         defaultMakerAssetAddress = erc20TokenA.address;
         defaultTakerAssetAddress = erc20TokenB.address;
 
@@ -133,6 +155,26 @@ describe('Exchange core', () => {
             signedOrder = await orderFactory.newSignedOrderAsync();
         });
 
+        const reentrancyTest = (functionNames: string[]) => {
+            _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                const description = `should not allow fillOrder to reenter the Exchange contract via ${functionName}`;
+                it(description, async () => {
+                    signedOrder = await orderFactory.newSignedOrderAsync({
+                        makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                    });
+                    await web3Wrapper.awaitTransactionSuccessAsync(
+                        await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                        constants.AWAIT_TRANSACTION_MINED_MS,
+                    );
+                    await expectTransactionFailedAsync(
+                        exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
+                        RevertReason.TransferFailed,
+                    );
+                });
+            });
+        };
+        describe('fillOrder reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
         it('should throw if signature is invalid', async () => {
             signedOrder = await orderFactory.newSignedOrderAsync({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
@@ -159,6 +201,216 @@ describe('Exchange core', () => {
                 RevertReason.OrderUnfillable,
             );
         });
+
+        it('should revert if `isValidSignature` tries to update state when SignatureType=Wallet', async () => {
+            const maliciousMakerAddress = maliciousWallet.address;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20TokenA.setBalance.sendTransactionAsync(
+                    maliciousMakerAddress,
+                    constants.INITIAL_ERC20_BALANCE,
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await maliciousWallet.approveERC20.sendTransactionAsync(
+                    erc20TokenA.address,
+                    erc20Proxy.address,
+                    constants.INITIAL_ERC20_ALLOWANCE,
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAddress: maliciousMakerAddress,
+                makerFee: constants.ZERO_AMOUNT,
+            });
+            signedOrder.signature = `0x0${SignatureType.Wallet}`;
+            await expectTransactionFailedAsync(
+                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
+                RevertReason.WalletError,
+            );
+        });
+
+        it('should revert if `isValidSignature` tries to update state when SignatureType=Validator', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await exchange.setSignatureValidatorApproval.sendTransactionAsync(
+                    maliciousValidator.address,
+                    isApproved,
+                    { from: makerAddress },
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            signedOrder.signature = `${maliciousValidator.address}0${SignatureType.Validator}`;
+            await expectTransactionFailedAsync(
+                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
+                RevertReason.ValidatorError,
+            );
+        });
+
+        it('should not emit transfer events for transfers where from == to', async () => {
+            const txReceipt = await exchangeWrapper.fillOrderAsync(signedOrder, makerAddress);
+            const logs = txReceipt.logs;
+            const transferLogs = _.filter(
+                logs,
+                log => (log as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).event === 'Transfer',
+            );
+            expect(transferLogs.length).to.be.equal(2);
+            expect((transferLogs[0] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).address).to.be.equal(
+                zrxToken.address,
+            );
+            expect((transferLogs[0] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._from).to.be.equal(
+                makerAddress,
+            );
+            expect((transferLogs[0] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._to).to.be.equal(
+                feeRecipientAddress,
+            );
+            expect(
+                (transferLogs[0] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._value,
+            ).to.be.bignumber.equal(signedOrder.makerFee);
+            expect((transferLogs[1] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).address).to.be.equal(
+                zrxToken.address,
+            );
+            expect((transferLogs[1] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._from).to.be.equal(
+                makerAddress,
+            );
+            expect((transferLogs[1] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._to).to.be.equal(
+                feeRecipientAddress,
+            );
+            expect(
+                (transferLogs[1] as LogWithDecodedArgs<DummyERC20TokenTransferEventArgs>).args._value,
+            ).to.be.bignumber.equal(signedOrder.takerFee);
+        });
+    });
+
+    describe('Testing exchange of ERC20 tokens with no return values', () => {
+        before(async () => {
+            noReturnErc20Token = await DummyNoReturnERC20TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyNoReturnERC20Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+                constants.DUMMY_TOKEN_DECIMALS,
+                constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await noReturnErc20Token.setBalance.sendTransactionAsync(makerAddress, constants.INITIAL_ERC20_BALANCE),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await noReturnErc20Token.approve.sendTransactionAsync(
+                    erc20Proxy.address,
+                    constants.INITIAL_ERC20_ALLOWANCE,
+                    { from: makerAddress },
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
     });
 
     describe('cancelOrder', () => {
@@ -315,7 +567,7 @@ describe('Exchange core', () => {
                 // HACK(albrow): We need to hardcode the gas estimate here because
                 // the Geth gas estimator doesn't work with the way we use
                 // delegatecall and swallow errors.
-                gas: 490000,
+                gas: 600000,
             });
 
             const newBalances = await erc20Wrapper.getBalancesAsync();
diff --git a/packages/contracts/test/exchange/dispatcher.ts b/packages/contracts/test/exchange/dispatcher.ts
index 81d142ca4..a8ae897a8 100644
--- a/packages/contracts/test/exchange/dispatcher.ts
+++ b/packages/contracts/test/exchange/dispatcher.ts
@@ -145,7 +145,7 @@ describe('AssetProxyDispatcher', () => {
         });
 
         it('should log an event with correct arguments when an asset proxy is registered', async () => {
-            const logDecoder = new LogDecoder(web3Wrapper, assetProxyDispatcher.address);
+            const logDecoder = new LogDecoder(web3Wrapper);
             const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
                 await assetProxyDispatcher.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
             );
@@ -205,6 +205,60 @@ describe('AssetProxyDispatcher', () => {
             );
         });
 
+        it('should not dispatch a transfer if amount == 0', async () => {
+            // Register ERC20 proxy
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await assetProxyDispatcher.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            // Construct metadata for ERC20 proxy
+            const encodedAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const erc20Balances = await erc20Wrapper.getBalancesAsync();
+            const amount = constants.ZERO_AMOUNT;
+            const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                await assetProxyDispatcher.publicDispatchTransferFrom.sendTransactionAsync(
+                    encodedAssetData,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: owner },
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            expect(txReceipt.logs.length).to.be.equal(0);
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            expect(newBalances).to.deep.equal(erc20Balances);
+        });
+
+        it('should not dispatch a transfer if from == to', async () => {
+            // Register ERC20 proxy
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await assetProxyDispatcher.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            // Construct metadata for ERC20 proxy
+            const encodedAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const erc20Balances = await erc20Wrapper.getBalancesAsync();
+            const amount = new BigNumber(10);
+            const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(
+                await assetProxyDispatcher.publicDispatchTransferFrom.sendTransactionAsync(
+                    encodedAssetData,
+                    makerAddress,
+                    makerAddress,
+                    amount,
+                    { from: owner },
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            expect(txReceipt.logs.length).to.be.equal(0);
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            expect(newBalances).to.deep.equal(erc20Balances);
+        });
+
         it('should throw if dispatching to unregistered proxy', async () => {
             // Construct metadata for ERC20 proxy
             const encodedAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
diff --git a/packages/contracts/test/exchange/fill_order.ts b/packages/contracts/test/exchange/fill_order.ts
index 1494fe093..b1e08324f 100644
--- a/packages/contracts/test/exchange/fill_order.ts
+++ b/packages/contracts/test/exchange/fill_order.ts
@@ -104,6 +104,17 @@ describe('FillOrder Tests', () => {
             };
             await fillOrderCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
         });
+        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount with zero decimals', async () => {
+            const fillScenario = {
+                ...defaultFillScenario,
+                orderScenario: {
+                    ...defaultFillScenario.orderScenario,
+                    makerAssetAmountScenario: OrderAssetAmountScenario.Small,
+                    makerAssetDataScenario: AssetDataScenario.ERC20ZeroDecimals,
+                },
+            };
+            await fillOrderCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
         it('should transfer the correct amounts when taker is specified and order is claimed by taker', async () => {
             const fillScenario = {
                 ...defaultFillScenario,
@@ -220,7 +231,7 @@ describe('FillOrder Tests', () => {
         });
     });
 
-    describe('Testing Exchange of ERC721 Tokens', () => {
+    describe('Testing exchange of ERC721 Tokens', () => {
         it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
             const fillScenario = {
                 ...defaultFillScenario,
diff --git a/packages/contracts/test/exchange/internal.ts b/packages/contracts/test/exchange/internal.ts
index 67d1d2d2c..156e086af 100644
--- a/packages/contracts/test/exchange/internal.ts
+++ b/packages/contracts/test/exchange/internal.ts
@@ -1,14 +1,12 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
 import { Order, RevertReason, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
 import * as _ from 'lodash';
 
 import { TestExchangeInternalsContract } from '../../generated_contract_wrappers/test_exchange_internals';
 import { artifacts } from '../utils/artifacts';
-import {
-    getInvalidOpcodeErrorMessageForCallAsync,
-    getRevertReasonOrErrorMessageForSendTransactionAsync,
-} from '../utils/assertions';
+import { getRevertReasonOrErrorMessageForSendTransactionAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { bytes32Values, testCombinatoriallyWithReferenceFuncAsync, uint256Values } from '../utils/combinatorial_utils';
 import { constants } from '../utils/constants';
@@ -16,6 +14,8 @@ import { FillResults } from '../utils/types';
 import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
 
 chaiSetup.configure();
+const expect = chai.expect;
+
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 const MAX_UINT256 = new BigNumber(2).pow(256).minus(1);
@@ -43,26 +43,11 @@ const emptySignedOrder: SignedOrder = {
 
 const overflowErrorForCall = new Error(RevertReason.Uint256Overflow);
 
-async function referenceGetPartialAmountAsync(
-    numerator: BigNumber,
-    denominator: BigNumber,
-    target: BigNumber,
-): Promise<BigNumber> {
-    const invalidOpcodeErrorForCall = new Error(await getInvalidOpcodeErrorMessageForCallAsync());
-    const product = numerator.mul(target);
-    if (product.greaterThan(MAX_UINT256)) {
-        throw overflowErrorForCall;
-    }
-    if (denominator.eq(0)) {
-        throw invalidOpcodeErrorForCall;
-    }
-    return product.dividedToIntegerBy(denominator);
-}
-
 describe('Exchange core internal functions', () => {
     let testExchange: TestExchangeInternalsContract;
-    let invalidOpcodeErrorForCall: Error | undefined;
     let overflowErrorForSendTransaction: Error | undefined;
+    let divisionByZeroErrorForCall: Error | undefined;
+    let roundingErrorForCall: Error | undefined;
 
     before(async () => {
         await blockchainLifecycle.startAsync();
@@ -79,11 +64,86 @@ describe('Exchange core internal functions', () => {
         overflowErrorForSendTransaction = new Error(
             await getRevertReasonOrErrorMessageForSendTransactionAsync(RevertReason.Uint256Overflow),
         );
-        invalidOpcodeErrorForCall = new Error(await getInvalidOpcodeErrorMessageForCallAsync());
+        divisionByZeroErrorForCall = new Error(RevertReason.DivisionByZero);
+        roundingErrorForCall = new Error(RevertReason.RoundingError);
     });
     // Note(albrow): Don't forget to add beforeEach and afterEach calls to reset
     // the blockchain state for any tests which modify it!
 
+    async function referenceIsRoundingErrorFloorAsync(
+        numerator: BigNumber,
+        denominator: BigNumber,
+        target: BigNumber,
+    ): Promise<boolean> {
+        if (denominator.eq(0)) {
+            throw divisionByZeroErrorForCall;
+        }
+        if (numerator.eq(0)) {
+            return false;
+        }
+        if (target.eq(0)) {
+            return false;
+        }
+        const product = numerator.mul(target);
+        const remainder = product.mod(denominator);
+        const remainderTimes1000 = remainder.mul('1000');
+        const isError = remainderTimes1000.gte(product);
+        if (product.greaterThan(MAX_UINT256)) {
+            throw overflowErrorForCall;
+        }
+        if (remainderTimes1000.greaterThan(MAX_UINT256)) {
+            throw overflowErrorForCall;
+        }
+        return isError;
+    }
+
+    async function referenceIsRoundingErrorCeilAsync(
+        numerator: BigNumber,
+        denominator: BigNumber,
+        target: BigNumber,
+    ): Promise<boolean> {
+        if (denominator.eq(0)) {
+            throw divisionByZeroErrorForCall;
+        }
+        if (numerator.eq(0)) {
+            return false;
+        }
+        if (target.eq(0)) {
+            return false;
+        }
+        const product = numerator.mul(target);
+        const remainder = product.mod(denominator);
+        const error = denominator.sub(remainder).mod(denominator);
+        const errorTimes1000 = error.mul('1000');
+        const isError = errorTimes1000.gte(product);
+        if (product.greaterThan(MAX_UINT256)) {
+            throw overflowErrorForCall;
+        }
+        if (errorTimes1000.greaterThan(MAX_UINT256)) {
+            throw overflowErrorForCall;
+        }
+        return isError;
+    }
+
+    async function referenceSafeGetPartialAmountFloorAsync(
+        numerator: BigNumber,
+        denominator: BigNumber,
+        target: BigNumber,
+    ): Promise<BigNumber> {
+        if (denominator.eq(0)) {
+            throw divisionByZeroErrorForCall;
+        }
+        const isRoundingError = await referenceIsRoundingErrorFloorAsync(numerator, denominator, target);
+        if (isRoundingError) {
+            throw roundingErrorForCall;
+        }
+        const product = numerator.mul(target);
+        if (product.greaterThan(MAX_UINT256)) {
+            throw overflowErrorForCall;
+        }
+        return product.dividedToIntegerBy(denominator);
+    }
+
     describe('addFillResults', async () => {
         function makeFillResults(value: BigNumber): FillResults {
             return {
@@ -158,19 +218,22 @@ describe('Exchange core internal functions', () => {
             // in any mathematical operation in either the reference TypeScript
             // implementation or the Solidity implementation of
             // calculateFillResults.
+            const makerAssetFilledAmount = await referenceSafeGetPartialAmountFloorAsync(
+                takerAssetFilledAmount,
+                orderTakerAssetAmount,
+                otherAmount,
+            );
+            const order = makeOrder(otherAmount, orderTakerAssetAmount, otherAmount, otherAmount);
+            const orderMakerAssetAmount = order.makerAssetAmount;
             return {
-                makerAssetFilledAmount: await referenceGetPartialAmountAsync(
-                    takerAssetFilledAmount,
-                    orderTakerAssetAmount,
-                    otherAmount,
-                ),
+                makerAssetFilledAmount,
                 takerAssetFilledAmount,
-                makerFeePaid: await referenceGetPartialAmountAsync(
-                    takerAssetFilledAmount,
-                    orderTakerAssetAmount,
+                makerFeePaid: await referenceSafeGetPartialAmountFloorAsync(
+                    makerAssetFilledAmount,
+                    orderMakerAssetAmount,
                     otherAmount,
                 ),
-                takerFeePaid: await referenceGetPartialAmountAsync(
+                takerFeePaid: await referenceSafeGetPartialAmountFloorAsync(
                     takerAssetFilledAmount,
                     orderTakerAssetAmount,
                     otherAmount,
@@ -193,60 +256,158 @@ describe('Exchange core internal functions', () => {
         );
     });
 
-    describe('getPartialAmount', async () => {
-        async function testGetPartialAmountAsync(
+    describe('getPartialAmountFloor', async () => {
+        async function referenceGetPartialAmountFloorAsync(
             numerator: BigNumber,
             denominator: BigNumber,
             target: BigNumber,
         ): Promise<BigNumber> {
-            return testExchange.publicGetPartialAmount.callAsync(numerator, denominator, target);
+            if (denominator.eq(0)) {
+                throw divisionByZeroErrorForCall;
+            }
+            const product = numerator.mul(target);
+            if (product.greaterThan(MAX_UINT256)) {
+                throw overflowErrorForCall;
+            }
+            return product.dividedToIntegerBy(denominator);
+        }
+        async function testGetPartialAmountFloorAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<BigNumber> {
+            return testExchange.publicGetPartialAmountFloor.callAsync(numerator, denominator, target);
         }
         await testCombinatoriallyWithReferenceFuncAsync(
-            'getPartialAmount',
-            referenceGetPartialAmountAsync,
-            testGetPartialAmountAsync,
+            'getPartialAmountFloor',
+            referenceGetPartialAmountFloorAsync,
+            testGetPartialAmountFloorAsync,
             [uint256Values, uint256Values, uint256Values],
         );
     });
 
-    describe('isRoundingError', async () => {
-        async function referenceIsRoundingErrorAsync(
+    describe('getPartialAmountCeil', async () => {
+        async function referenceGetPartialAmountCeilAsync(
             numerator: BigNumber,
             denominator: BigNumber,
             target: BigNumber,
-        ): Promise<boolean> {
-            const product = numerator.mul(target);
+        ): Promise<BigNumber> {
             if (denominator.eq(0)) {
-                throw invalidOpcodeErrorForCall;
-            }
-            const remainder = product.mod(denominator);
-            if (remainder.eq(0)) {
-                return false;
+                throw divisionByZeroErrorForCall;
             }
-            if (product.greaterThan(MAX_UINT256)) {
+            const product = numerator.mul(target);
+            const offset = product.add(denominator.sub(1));
+            if (offset.greaterThan(MAX_UINT256)) {
                 throw overflowErrorForCall;
             }
-            if (product.eq(0)) {
-                throw invalidOpcodeErrorForCall;
+            const result = offset.dividedToIntegerBy(denominator);
+            if (product.mod(denominator).eq(0)) {
+                expect(result.mul(denominator)).to.be.bignumber.eq(product);
+            } else {
+                expect(result.mul(denominator)).to.be.bignumber.gt(product);
             }
-            const remainderTimes1000000 = remainder.mul('1000000');
-            if (remainderTimes1000000.greaterThan(MAX_UINT256)) {
+            return result;
+        }
+        async function testGetPartialAmountCeilAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<BigNumber> {
+            return testExchange.publicGetPartialAmountCeil.callAsync(numerator, denominator, target);
+        }
+        await testCombinatoriallyWithReferenceFuncAsync(
+            'getPartialAmountCeil',
+            referenceGetPartialAmountCeilAsync,
+            testGetPartialAmountCeilAsync,
+            [uint256Values, uint256Values, uint256Values],
+        );
+    });
+
+    describe('safeGetPartialAmountFloor', async () => {
+        async function testSafeGetPartialAmountFloorAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<BigNumber> {
+            return testExchange.publicSafeGetPartialAmountFloor.callAsync(numerator, denominator, target);
+        }
+        await testCombinatoriallyWithReferenceFuncAsync(
+            'safeGetPartialAmountFloor',
+            referenceSafeGetPartialAmountFloorAsync,
+            testSafeGetPartialAmountFloorAsync,
+            [uint256Values, uint256Values, uint256Values],
+        );
+    });
+
+    describe('safeGetPartialAmountCeil', async () => {
+        async function referenceSafeGetPartialAmountCeilAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<BigNumber> {
+            if (denominator.eq(0)) {
+                throw divisionByZeroErrorForCall;
+            }
+            const isRoundingError = await referenceIsRoundingErrorCeilAsync(numerator, denominator, target);
+            if (isRoundingError) {
+                throw roundingErrorForCall;
+            }
+            const product = numerator.mul(target);
+            const offset = product.add(denominator.sub(1));
+            if (offset.greaterThan(MAX_UINT256)) {
                 throw overflowErrorForCall;
             }
-            const errPercentageTimes1000000 = remainderTimes1000000.dividedToIntegerBy(product);
-            return errPercentageTimes1000000.greaterThan('1000');
+            const result = offset.dividedToIntegerBy(denominator);
+            if (product.mod(denominator).eq(0)) {
+                expect(result.mul(denominator)).to.be.bignumber.eq(product);
+            } else {
+                expect(result.mul(denominator)).to.be.bignumber.gt(product);
+            }
+            return result;
+        }
+        async function testSafeGetPartialAmountCeilAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<BigNumber> {
+            return testExchange.publicSafeGetPartialAmountCeil.callAsync(numerator, denominator, target);
+        }
+        await testCombinatoriallyWithReferenceFuncAsync(
+            'safeGetPartialAmountCeil',
+            referenceSafeGetPartialAmountCeilAsync,
+            testSafeGetPartialAmountCeilAsync,
+            [uint256Values, uint256Values, uint256Values],
+        );
+    });
+
+    describe('isRoundingErrorFloor', async () => {
+        async function testIsRoundingErrorFloorAsync(
+            numerator: BigNumber,
+            denominator: BigNumber,
+            target: BigNumber,
+        ): Promise<boolean> {
+            return testExchange.publicIsRoundingErrorFloor.callAsync(numerator, denominator, target);
         }
-        async function testIsRoundingErrorAsync(
+        await testCombinatoriallyWithReferenceFuncAsync(
+            'isRoundingErrorFloor',
+            referenceIsRoundingErrorFloorAsync,
+            testIsRoundingErrorFloorAsync,
+            [uint256Values, uint256Values, uint256Values],
+        );
+    });
+
+    describe('isRoundingErrorCeil', async () => {
+        async function testIsRoundingErrorCeilAsync(
             numerator: BigNumber,
             denominator: BigNumber,
             target: BigNumber,
         ): Promise<boolean> {
-            return testExchange.publicIsRoundingError.callAsync(numerator, denominator, target);
+            return testExchange.publicIsRoundingErrorCeil.callAsync(numerator, denominator, target);
         }
         await testCombinatoriallyWithReferenceFuncAsync(
-            'isRoundingError',
-            referenceIsRoundingErrorAsync,
-            testIsRoundingErrorAsync,
+            'isRoundingErrorCeil',
+            referenceIsRoundingErrorCeilAsync,
+            testIsRoundingErrorCeilAsync,
             [uint256Values, uint256Values, uint256Values],
         );
     });
diff --git a/packages/contracts/test/exchange/libs.ts b/packages/contracts/test/exchange/libs.ts
index 5c9f9aac7..37234489e 100644
--- a/packages/contracts/test/exchange/libs.ts
+++ b/packages/contracts/test/exchange/libs.ts
@@ -1,5 +1,5 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { assetDataUtils, EIP712Utils, orderHashUtils } from '@0xproject/order-utils';
+import { assetDataUtils, eip712Utils, orderHashUtils } from '@0xproject/order-utils';
 import { SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
@@ -71,29 +71,57 @@ describe('Exchange libs', () => {
     // combinatorial tests in test/exchange/internal. They test specific edge
     // cases that are not covered by the combinatorial tests.
     describe('LibMath', () => {
-        it('should return false if there is a rounding error of 0.1%', async () => {
-            const numerator = new BigNumber(20);
-            const denominator = new BigNumber(999);
-            const target = new BigNumber(50);
-            // rounding error = ((20*50/999) - floor(20*50/999)) / (20*50/999) = 0.1%
-            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-            expect(isRoundingError).to.be.false();
-        });
-        it('should return false if there is a rounding of 0.09%', async () => {
-            const numerator = new BigNumber(20);
-            const denominator = new BigNumber(9991);
-            const target = new BigNumber(500);
-            // rounding error = ((20*500/9991) - floor(20*500/9991)) / (20*500/9991) = 0.09%
-            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-            expect(isRoundingError).to.be.false();
+        describe('isRoundingError', () => {
+            it('should return true if there is a rounding error of 0.1%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(999);
+                const target = new BigNumber(50);
+                // rounding error = ((20*50/999) - floor(20*50/999)) / (20*50/999) = 0.1%
+                const isRoundingError = await libs.publicIsRoundingErrorFloor.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.true();
+            });
+            it('should return false if there is a rounding of 0.09%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(9991);
+                const target = new BigNumber(500);
+                // rounding error = ((20*500/9991) - floor(20*500/9991)) / (20*500/9991) = 0.09%
+                const isRoundingError = await libs.publicIsRoundingErrorFloor.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.false();
+            });
+            it('should return true if there is a rounding error of 0.11%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(9989);
+                const target = new BigNumber(500);
+                // rounding error = ((20*500/9989) - floor(20*500/9989)) / (20*500/9989) = 0.011%
+                const isRoundingError = await libs.publicIsRoundingErrorFloor.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.true();
+            });
         });
-        it('should return true if there is a rounding error of 0.11%', async () => {
-            const numerator = new BigNumber(20);
-            const denominator = new BigNumber(9989);
-            const target = new BigNumber(500);
-            // rounding error = ((20*500/9989) - floor(20*500/9989)) / (20*500/9989) = 0.011%
-            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-            expect(isRoundingError).to.be.true();
+        describe('isRoundingErrorCeil', () => {
+            it('should return true if there is a rounding error of 0.1%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(1001);
+                const target = new BigNumber(50);
+                // rounding error = (ceil(20*50/1001) - (20*50/1001)) / (20*50/1001) = 0.1%
+                const isRoundingError = await libs.publicIsRoundingErrorCeil.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.true();
+            });
+            it('should return false if there is a rounding of 0.09%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(10009);
+                const target = new BigNumber(500);
+                // rounding error = (ceil(20*500/10009) - (20*500/10009)) / (20*500/10009) = 0.09%
+                const isRoundingError = await libs.publicIsRoundingErrorCeil.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.false();
+            });
+            it('should return true if there is a rounding error of 0.11%', async () => {
+                const numerator = new BigNumber(20);
+                const denominator = new BigNumber(10011);
+                const target = new BigNumber(500);
+                // rounding error = (ceil(20*500/10011) - (20*500/10011)) / (20*500/10011) = 0.11%
+                const isRoundingError = await libs.publicIsRoundingErrorCeil.callAsync(numerator, denominator, target);
+                expect(isRoundingError).to.be.true();
+            });
         });
     });
 
@@ -109,7 +137,7 @@ describe('Exchange libs', () => {
         describe('getDomainSeparatorSchema', () => {
             it('should output the correct domain separator schema hash', async () => {
                 const domainSeparatorSchema = await libs.getDomainSeparatorSchemaHash.callAsync();
-                const domainSchemaBuffer = EIP712Utils._getDomainSeparatorSchemaBuffer();
+                const domainSchemaBuffer = eip712Utils._getDomainSeparatorSchemaBuffer();
                 const schemaHashHex = `0x${domainSchemaBuffer.toString('hex')}`;
                 expect(schemaHashHex).to.be.equal(domainSeparatorSchema);
             });
diff --git a/packages/contracts/test/exchange/match_orders.ts b/packages/contracts/test/exchange/match_orders.ts
index 46b3569bd..c6e7b494f 100644
--- a/packages/contracts/test/exchange/match_orders.ts
+++ b/packages/contracts/test/exchange/match_orders.ts
@@ -11,6 +11,8 @@ import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dumm
 import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
 import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
 import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { ReentrantERC20TokenContract } from '../../generated_contract_wrappers/reentrant_erc20_token';
+import { TestExchangeInternalsContract } from '../../generated_contract_wrappers/test_exchange_internals';
 import { artifacts } from '../utils/artifacts';
 import { expectTransactionFailedAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
@@ -20,12 +22,12 @@ import { ERC721Wrapper } from '../utils/erc721_wrapper';
 import { ExchangeWrapper } from '../utils/exchange_wrapper';
 import { MatchOrderTester } from '../utils/match_order_tester';
 import { OrderFactory } from '../utils/order_factory';
-import { ERC20BalancesByOwner, ERC721TokenIdsByOwner, OrderInfo, OrderStatus } from '../utils/types';
+import { ERC20BalancesByOwner, ERC721TokenIdsByOwner } from '../utils/types';
 import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
 
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 chaiSetup.configure();
 const expect = chai.expect;
-const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
 describe('matchOrders', () => {
     let makerAddressLeft: string;
@@ -39,6 +41,7 @@ describe('matchOrders', () => {
     let erc20TokenB: DummyERC20TokenContract;
     let zrxToken: DummyERC20TokenContract;
     let erc721Token: DummyERC721TokenContract;
+    let reentrantErc20Token: ReentrantERC20TokenContract;
     let exchange: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
@@ -60,6 +63,8 @@ describe('matchOrders', () => {
 
     let matchOrderTester: MatchOrderTester;
 
+    let testExchange: TestExchangeInternalsContract;
+
     before(async () => {
         await blockchainLifecycle.startAsync();
     });
@@ -127,23 +132,46 @@ describe('matchOrders', () => {
             }),
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
+
+        reentrantErc20Token = await ReentrantERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.ReentrantERC20Token,
+            provider,
+            txDefaults,
+            exchange.address,
+        );
+
         // Set default addresses
         defaultERC20MakerAssetAddress = erc20TokenA.address;
         defaultERC20TakerAssetAddress = erc20TokenB.address;
         defaultERC721AssetAddress = erc721Token.address;
         // Create default order parameters
-        const defaultOrderParams = {
+        const defaultOrderParamsLeft = {
             ...constants.STATIC_ORDER_PARAMS,
+            makerAddress: makerAddressLeft,
             exchangeAddress: exchange.address,
             makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
             takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
+            feeRecipientAddress: feeRecipientAddressLeft,
+        };
+        const defaultOrderParamsRight = {
+            ...constants.STATIC_ORDER_PARAMS,
+            makerAddress: makerAddressRight,
+            exchangeAddress: exchange.address,
+            makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
+            takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
+            feeRecipientAddress: feeRecipientAddressRight,
         };
         const privateKeyLeft = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddressLeft)];
-        orderFactoryLeft = new OrderFactory(privateKeyLeft, defaultOrderParams);
+        orderFactoryLeft = new OrderFactory(privateKeyLeft, defaultOrderParamsLeft);
         const privateKeyRight = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddressRight)];
-        orderFactoryRight = new OrderFactory(privateKeyRight, defaultOrderParams);
+        orderFactoryRight = new OrderFactory(privateKeyRight, defaultOrderParamsRight);
         // Set match order tester
         matchOrderTester = new MatchOrderTester(exchangeWrapper, erc20Wrapper, erc721Wrapper, zrxToken.address);
+        testExchange = await TestExchangeInternalsContract.deployFrom0xArtifactAsync(
+            artifacts.TestExchangeInternals,
+            provider,
+            txDefaults,
+        );
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -157,263 +185,674 @@ describe('matchOrders', () => {
             erc721TokenIdsByOwner = await erc721Wrapper.getBalancesAsync();
         });
 
-        it('should transfer the correct amounts when orders completely fill each other', async () => {
+        it('Should transfer correct amounts when right order is fully filled and values pass isRoundingErrorFloor but fail isRoundingErrorCeil', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
                 makerAddress: makerAddressLeft,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(17), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(98), 0),
                 feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(75), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
                 feeRecipientAddress: feeRecipientAddressRight,
             });
+            // Assert is rounding error ceil & not rounding error floor
+            // These assertions are taken from MixinMatchOrders::calculateMatchedFillResults
+            // The rounding error is derived computating how much the left maker will sell.
+            const numerator = signedOrderLeft.makerAssetAmount;
+            const denominator = signedOrderLeft.takerAssetAmount;
+            const target = signedOrderRight.makerAssetAmount;
+            const isRoundingErrorCeil = await testExchange.publicIsRoundingErrorCeil.callAsync(
+                numerator,
+                denominator,
+                target,
+            );
+            expect(isRoundingErrorCeil).to.be.true();
+            const isRoundingErrorFloor = await testExchange.publicIsRoundingErrorFloor.callAsync(
+                numerator,
+                denominator,
+                target,
+            );
+            expect(isRoundingErrorFloor).to.be.false();
             // Match signedOrderLeft with signedOrderRight
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            // Note that the left maker received a slightly better sell price.
+            // This is intentional; see note in MixinMatchOrders.calculateMatchedFillResults.
+            // Because the left maker received a slightly more favorable sell price, the fee
+            // paid by the left taker is slightly higher than that paid by the left maker.
+            // Fees can be thought of as a tax paid by the seller, derived from the sale price.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(75), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber('76.4705882352941176'), 16), // 76.47%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(75), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber('76.5306122448979591'), 16), // 76.53%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
         });
 
-        it('should transfer the correct amounts when orders completely fill each other and taker doesnt take a profit', async () => {
+        it('Should transfer correct amounts when left order is fully filled and values pass isRoundingErrorCeil but fail isRoundingErrorFloor', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
                 makerAddress: makerAddressLeft,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(15), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 0),
                 feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(97), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(14), 0),
                 feeRecipientAddress: feeRecipientAddressRight,
             });
-            // Store original taker balance
-            const takerInitialBalances = _.cloneDeep(erc20BalancesByOwner[takerAddress][defaultERC20MakerAssetAddress]);
+            // Assert is rounding error floor & not rounding error ceil
+            // These assertions are taken from MixinMatchOrders::calculateMatchedFillResults
+            // The rounding error is derived computating how much the right maker will buy.
+            const numerator = signedOrderRight.takerAssetAmount;
+            const denominator = signedOrderRight.makerAssetAmount;
+            const target = signedOrderLeft.takerAssetAmount;
+            const isRoundingErrorFloor = await testExchange.publicIsRoundingErrorFloor.callAsync(
+                numerator,
+                denominator,
+                target,
+            );
+            expect(isRoundingErrorFloor).to.be.true();
+            const isRoundingErrorCeil = await testExchange.publicIsRoundingErrorCeil.callAsync(
+                numerator,
+                denominator,
+                target,
+            );
+            expect(isRoundingErrorCeil).to.be.false();
             // Match signedOrderLeft with signedOrderRight
-            let newERC20BalancesByOwner: ERC20BalancesByOwner;
-            let newERC721TokenIdsByOwner: ERC721TokenIdsByOwner;
-            // prettier-ignore
-            [
-                newERC20BalancesByOwner,
-                // tslint:disable-next-line:trailing-comma
-                newERC721TokenIdsByOwner
-            ] = await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            // Note that the right maker received a slightly better purchase price.
+            // This is intentional; see note in MixinMatchOrders.calculateMatchedFillResults.
+            // Because the right maker received a slightly more favorable buy price, the fee
+            // paid by the right taker is slightly higher than that paid by the right maker.
+            // Fees can be thought of as a tax paid by the seller, derived from the sale price.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(15), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber('92.7835051546391752'), 16), // 92.78%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber('92.8571428571428571'), 16), // 92.85%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify taker did not take a profit
-            expect(takerInitialBalances).to.be.deep.equal(
-                newERC20BalancesByOwner[takerAddress][defaultERC20MakerAssetAddress],
+        });
+
+        it('Should give right maker a better buy price when rounding', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAddress: makerAddressLeft,
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(16), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
+                feeRecipientAddress: feeRecipientAddressLeft,
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAddress: makerAddressRight,
+                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
+                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(83), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(49), 0),
+                feeRecipientAddress: feeRecipientAddressRight,
+            });
+            // Note:
+            // The correct price buy price for the right maker would yield (49/83) * 22 = 12.988 units
+            // of the left maker asset. This gets rounded up to 13, giving the right maker a better price.
+            // Note:
+            //  The maker/taker fee percentage paid on the right order differs because
+            //  they received different sale prices. The right maker pays a
+            //  fee slightly lower than the right taker.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(16), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber('26.5060240963855421'), 16), // 26.506%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber('26.5306122448979591'), 16), // 26.531%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
-        it('should transfer the correct amounts when left order is completely filled and right order is partially filled', async () => {
+        it('Should give left maker a better sell price when rounding', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
                 makerAddress: makerAddressLeft,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(12), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(97), 0),
                 feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(20), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
                 feeRecipientAddress: feeRecipientAddressRight,
             });
-            // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            // Note:
+            //  The maker/taker fee percentage paid on the left order differs because
+            //  they received different sale prices. The left maker pays a fee
+            //  slightly lower than the left taker.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(11), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber('91.6666666666666666'), 16), // 91.6%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber('91.7525773195876288'), 16), // 91.75%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was partially filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
         });
 
-        it('should transfer the correct amounts when right order is completely filled and left order is partially filled', async () => {
+        it('Should give right maker and right taker a favorable fee price when rounding', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
                 makerAddress: makerAddressLeft,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(16), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
                 feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(83), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(49), 0),
                 feeRecipientAddress: feeRecipientAddressRight,
+                makerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(10000), 0),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(10000), 0),
             });
-            // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            // Note:
+            //  The maker/taker fee percentage paid on the right order differs because
+            //  they received different sale prices. The right maker pays a
+            //  fee slightly lower than the right taker.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(16), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(22), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(13), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2650), 0), // 2650.6 rounded down tro 2650
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(2653), 0), // 2653.1 rounded down to 2653
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was partially filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
         });
 
-        it('should transfer the correct amounts when consecutive calls are used to completely fill the left order', async () => {
+        it('Should give left maker and left taker a favorable fee price when rounding', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
                 makerAddress: makerAddressLeft,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(12), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(97), 0),
                 feeRecipientAddress: feeRecipientAddressLeft,
+                makerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(10000), 0),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(10000), 0),
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                feeRecipientAddress: feeRecipientAddressRight,
+            });
+            // Note:
+            //  The maker/taker fee percentage paid on the left order differs because
+            //  they received different sale prices. The left maker pays a
+            //  fee slightly lower than the left taker.
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(11), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(9166), 0), // 9166.6 rounded down to 9166
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(89), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(9175), 0), // 9175.2 rounded down to 9175
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        it('Should transfer correct amounts when right order fill amount deviates from amount derived by `Exchange.fillOrder`', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAddress: makerAddressLeft,
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1000), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1005), 0),
+                feeRecipientAddress: feeRecipientAddressLeft,
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAddress: makerAddressRight,
+                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
+                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2126), 0),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1063), 0),
+                feeRecipientAddress: feeRecipientAddressRight,
+            });
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1000), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1005), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                // Notes:
+                //  i.
+                //    The left order is fully filled by the right order, so the right maker must sell 1005 units of their asset to the left maker.
+                //    By selling 1005 units, the right maker should theoretically receive 502.5 units of the left maker's asset.
+                //    Since the transfer amount must be an integer, this value must be rounded down to 502 or up to 503.
+                //  ii.
+                //    If the right order were filled via `Exchange.fillOrder` the respective fill amounts would be [1004, 502] or [1006, 503].
+                //    It follows that we cannot trigger a sale of 1005 units of the right maker's asset through `Exchange.fillOrder`.
+                //  iii.
+                //    For an optimal match, the algorithm must choose either [1005, 502] or [1005, 503] as fill amounts for the right order.
+                //    The algorithm favors the right maker when the exchange rate must be rounded, so the final fill for the right order is [1005, 503].
+                //  iv.
+                //    The right maker fee differs from the right taker fee because their exchange rate differs.
+                //    The right maker always receives the better exchange and fee price.
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1005), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(503), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber('47.2718720602069614'), 16), // 47.27%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(497), 0),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber('47.3189087488240827'), 16), // 47.31%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        const reentrancyTest = (functionNames: string[]) => {
+            _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                const description = `should not allow matchOrders to reenter the Exchange contract via ${functionName}`;
+                it(description, async () => {
+                    const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                        makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                        takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                    });
+                    const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                        makerAddress: makerAddressRight,
+                        takerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                        takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                        feeRecipientAddress: feeRecipientAddressRight,
+                    });
+                    await web3Wrapper.awaitTransactionSuccessAsync(
+                        await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                        constants.AWAIT_TRANSACTION_MINED_MS,
+                    );
+                    await expectTransactionFailedAsync(
+                        exchangeWrapper.matchOrdersAsync(signedOrderLeft, signedOrderRight, takerAddress),
+                        RevertReason.TransferFailed,
+                    );
+                });
+            });
+        };
+        describe('matchOrders reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
+        it('should transfer the correct amounts when orders completely fill each other', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+            });
+            // Match signedOrderLeft with signedOrderRight
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        it('should transfer the correct amounts when orders completely fill each other and taker doesnt take a profit', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+            });
+            // Match signedOrderLeft with signedOrderRight
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        it('should transfer the correct amounts when left order is completely filled and right order is partially filled', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(20), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), 18),
+            });
+            // Match signedOrderLeft with signedOrderRight
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 16), // 50%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 16), // 50%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        it('should transfer the correct amounts when right order is completely filled and left order is partially filled', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+            });
+            // Match signedOrderLeft with signedOrderRight
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 16), // 10%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 16), // 10%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            // Match signedOrderLeft with signedOrderRight
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
+                signedOrderLeft,
+                signedOrderRight,
+                takerAddress,
+                erc20BalancesByOwner,
+                erc721TokenIdsByOwner,
+                expectedTransferAmounts,
+            );
+        });
+
+        it('should transfer the correct amounts when consecutive calls are used to completely fill the left order', async () => {
+            // Create orders to match
+            const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+            const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             let newERC20BalancesByOwner: ERC20BalancesByOwner;
             let newERC721TokenIdsByOwner: ERC721TokenIdsByOwner;
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 16), // 10%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 16), // 10%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
             // prettier-ignore
             [
                 newERC20BalancesByOwner,
                 // tslint:disable-next-line:trailing-comma
                 newERC721TokenIdsByOwner
-            ] = await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            ] = await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was partially filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
             // Construct second right order
             // Note: This order needs makerAssetAmount=90/takerAssetAmount=[anything <= 45] to fully fill the right order.
             //       However, we use 100/50 to ensure a partial fill as we want to go down the "left fill"
             //       branch in the contract twice for this test.
             const signedOrderRight2 = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match signedOrderLeft with signedOrderRight2
             const leftTakerAssetFilledAmount = signedOrderRight.makerAssetAmount;
             const rightTakerAssetFilledAmount = new BigNumber(0);
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts2 = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(45), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 16), // 90% (10% paid earlier)
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(45), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 16), // 90%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 16), // 90% (10% paid earlier)
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(90), 16), // 90%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight2,
                 takerAddress,
                 newERC20BalancesByOwner,
-                erc721TokenIdsByOwner,
+                newERC721TokenIdsByOwner,
+                expectedTransferAmounts2,
                 leftTakerAssetFilledAmount,
                 rightTakerAssetFilledAmount,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo2: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo2.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify second right order was partially filled
-            const rightOrderInfo2: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight2);
-            expect(rightOrderInfo2.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
         });
 
         it('should transfer the correct amounts when consecutive calls are used to completely fill the right order', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
 
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             let newERC20BalancesByOwner: ERC20BalancesByOwner;
             let newERC721TokenIdsByOwner: ERC721TokenIdsByOwner;
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), 16), // 4%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(6), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), 16), // 4%
+            };
             // prettier-ignore
             [
                 newERC20BalancesByOwner,
                 // tslint:disable-next-line:trailing-comma
                 newERC721TokenIdsByOwner
-            ] = await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            ] = await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was partially filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
+
             // Create second left order
             // Note: This order needs makerAssetAmount=96/takerAssetAmount=48 to fully fill the right order.
             //       However, we use 100/50 to ensure a partial fill as we want to go down the "right fill"
             //       branch in the contract twice for this test.
             const signedOrderLeft2 = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             // Match signedOrderLeft2 with signedOrderRight
             const leftTakerAssetFilledAmount = new BigNumber(0);
@@ -421,198 +860,257 @@ describe('matchOrders', () => {
                 erc20BalancesByOwner[takerAddress][defaultERC20MakerAssetAddress],
             );
             const rightTakerAssetFilledAmount = signedOrderLeft.makerAssetAmount.minus(takerAmountReceived);
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts2 = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(48), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 16), // 96%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(48), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 16), // 96%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 16), // 96%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(96), 16), // 96%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft2,
                 signedOrderRight,
                 takerAddress,
                 newERC20BalancesByOwner,
-                erc721TokenIdsByOwner,
+                newERC721TokenIdsByOwner,
+                expectedTransferAmounts2,
                 leftTakerAssetFilledAmount,
                 rightTakerAssetFilledAmount,
             );
-            // Verify second left order was partially filled
-            const leftOrderInfo2: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft2);
-            expect(leftOrderInfo2.orderStatus as OrderStatus).to.be.equal(OrderStatus.FILLABLE);
-            // Verify right order was fully filled
-            const rightOrderInfo2: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo2.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
         });
 
         it('should transfer the correct amounts if fee recipient is the same across both matched orders', async () => {
             const feeRecipientAddress = feeRecipientAddressLeft;
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 feeRecipientAddress,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
                 feeRecipientAddress,
             });
             // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('should transfer the correct amounts if taker is also the left order maker', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             takerAddress = signedOrderLeft.makerAddress;
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('should transfer the correct amounts if taker is also the right order maker', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             takerAddress = signedOrderRight.makerAddress;
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('should transfer the correct amounts if taker is also the left fee recipient', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             takerAddress = feeRecipientAddressLeft;
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('should transfer the correct amounts if taker is also the right fee recipient', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             takerAddress = feeRecipientAddressRight;
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('should transfer the correct amounts if left maker is the left fee recipient and right maker is the right fee recipient', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: makerAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: makerAddressRight,
             });
             // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
         });
 
         it('Should throw if left order is not fillable', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Cancel left order
             await exchangeWrapper.cancelOrderAsync(signedOrderLeft, signedOrderLeft.makerAddress);
@@ -626,18 +1124,12 @@ describe('matchOrders', () => {
         it('Should throw if right order is not fillable', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Cancel right order
             await exchangeWrapper.cancelOrderAsync(signedOrderRight, signedOrderRight.makerAddress);
@@ -651,18 +1143,12 @@ describe('matchOrders', () => {
         it('should throw if there is not a positive spread', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             return expectTransactionFailedAsync(
@@ -674,18 +1160,13 @@ describe('matchOrders', () => {
         it('should throw if the left maker asset is not equal to the right taker asset ', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             return expectTransactionFailedAsync(
@@ -701,20 +1182,13 @@ describe('matchOrders', () => {
         it('should throw if the right maker asset is not equal to the left taker asset', async () => {
             // Create orders to match
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(5), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
             return expectTransactionFailedAsync(
@@ -727,70 +1201,76 @@ describe('matchOrders', () => {
             // Create orders to match
             const erc721TokenToTransfer = erc721LeftMakerAssetIds[0];
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
                 makerAssetData: assetDataUtils.encodeERC721AssetData(defaultERC721AssetAddress, erc721TokenToTransfer),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 makerAssetAmount: new BigNumber(1),
                 takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20TakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC721AssetData(defaultERC721AssetAddress, erc721TokenToTransfer),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: new BigNumber(1),
-                feeRecipientAddress: feeRecipientAddressRight,
             });
             // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 50%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
         });
 
         it('should transfer correct amounts when right order maker asset is an ERC721 token', async () => {
             // Create orders to match
             const erc721TokenToTransfer = erc721RightMakerAssetIds[0];
             const signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({
-                makerAddress: makerAddressLeft,
-                makerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 takerAssetData: assetDataUtils.encodeERC721AssetData(defaultERC721AssetAddress, erc721TokenToTransfer),
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
                 takerAssetAmount: new BigNumber(1),
-                feeRecipientAddress: feeRecipientAddressLeft,
             });
             const signedOrderRight = await orderFactoryRight.newSignedOrderAsync({
-                makerAddress: makerAddressRight,
                 makerAssetData: assetDataUtils.encodeERC721AssetData(defaultERC721AssetAddress, erc721TokenToTransfer),
-                takerAssetData: assetDataUtils.encodeERC20AssetData(defaultERC20MakerAssetAddress),
                 makerAssetAmount: new BigNumber(1),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
-                feeRecipientAddress: feeRecipientAddressRight,
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(8), 18),
             });
             // Match orders
-            await matchOrderTester.matchOrdersAndVerifyBalancesAsync(
+            const expectedTransferAmounts = {
+                // Left Maker
+                amountSoldByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
+                amountBoughtByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                feePaidByLeftMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Right Maker
+                amountSoldByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), 0),
+                amountBoughtByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(8), 18),
+                feePaidByRightMaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                // Taker
+                amountReceivedByTaker: Web3Wrapper.toBaseUnitAmount(new BigNumber(2), 18),
+                feePaidByTakerLeft: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+                feePaidByTakerRight: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 16), // 100%
+            };
+            await matchOrderTester.matchOrdersAndAssertEffectsAsync(
                 signedOrderLeft,
                 signedOrderRight,
                 takerAddress,
                 erc20BalancesByOwner,
                 erc721TokenIdsByOwner,
+                expectedTransferAmounts,
             );
-            // Verify left order was fully filled
-            const leftOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
-            expect(leftOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
-            // Verify right order was fully filled
-            const rightOrderInfo: OrderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrderRight);
-            expect(rightOrderInfo.orderStatus as OrderStatus).to.be.equal(OrderStatus.FULLY_FILLED);
         });
     });
 }); // tslint:disable-line:max-file-line-count
diff --git a/packages/contracts/test/exchange/signature_validator.ts b/packages/contracts/test/exchange/signature_validator.ts
index 56a06c247..5cc62e777 100644
--- a/packages/contracts/test/exchange/signature_validator.ts
+++ b/packages/contracts/test/exchange/signature_validator.ts
@@ -1,5 +1,5 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
-import { addSignedMessagePrefix, assetDataUtils, orderHashUtils } from '@0xproject/order-utils';
+import { assetDataUtils, orderHashUtils, signatureUtils } from '@0xproject/order-utils';
 import { RevertReason, SignatureType, SignedOrder, SignerType } from '@0xproject/types';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
@@ -9,11 +9,12 @@ import {
     TestSignatureValidatorContract,
     TestSignatureValidatorSignatureValidatorApprovalEventArgs,
 } from '../../generated_contract_wrappers/test_signature_validator';
+import { TestStaticCallReceiverContract } from '../../generated_contract_wrappers/test_static_call_receiver';
 import { ValidatorContract } from '../../generated_contract_wrappers/validator';
 import { WalletContract } from '../../generated_contract_wrappers/wallet';
 import { addressUtils } from '../utils/address_utils';
 import { artifacts } from '../utils/artifacts';
-import { expectContractCallFailed } from '../utils/assertions';
+import { expectContractCallFailedAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { LogDecoder } from '../utils/log_decoder';
@@ -31,6 +32,8 @@ describe('MixinSignatureValidator', () => {
     let signatureValidator: TestSignatureValidatorContract;
     let testWallet: WalletContract;
     let testValidator: ValidatorContract;
+    let maliciousWallet: TestStaticCallReceiverContract;
+    let maliciousValidator: TestStaticCallReceiverContract;
     let signerAddress: string;
     let signerPrivateKey: Buffer;
     let notSignerAddress: string;
@@ -65,13 +68,28 @@ describe('MixinSignatureValidator', () => {
             txDefaults,
             signerAddress,
         );
-        signatureValidatorLogDecoder = new LogDecoder(web3Wrapper, signatureValidator.address);
+        maliciousWallet = maliciousValidator = await TestStaticCallReceiverContract.deployFrom0xArtifactAsync(
+            artifacts.TestStaticCallReceiver,
+            provider,
+            txDefaults,
+        );
+        signatureValidatorLogDecoder = new LogDecoder(web3Wrapper);
         await web3Wrapper.awaitTransactionSuccessAsync(
             await signatureValidator.setSignatureValidatorApproval.sendTransactionAsync(testValidator.address, true, {
                 from: signerAddress,
             }),
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await signatureValidator.setSignatureValidatorApproval.sendTransactionAsync(
+                maliciousValidator.address,
+                true,
+                {
+                    from: signerAddress,
+                },
+            ),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
 
         const defaultOrderParams = {
             ...constants.STATIC_ORDER_PARAMS,
@@ -101,7 +119,7 @@ describe('MixinSignatureValidator', () => {
         it('should revert when signature is empty', async () => {
             const emptySignature = '0x';
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 signatureValidator.publicIsValidSignature.callAsync(
                     orderHashHex,
                     signedOrder.makerAddress,
@@ -115,7 +133,7 @@ describe('MixinSignatureValidator', () => {
             const unsupportedSignatureType = SignatureType.NSignatureTypes;
             const unsupportedSignatureHex = '0x' + Buffer.from([unsupportedSignatureType]).toString('hex');
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 signatureValidator.publicIsValidSignature.callAsync(
                     orderHashHex,
                     signedOrder.makerAddress,
@@ -128,7 +146,7 @@ describe('MixinSignatureValidator', () => {
         it('should revert when SignatureType=Illegal', async () => {
             const unsupportedSignatureHex = '0x' + Buffer.from([SignatureType.Illegal]).toString('hex');
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 signatureValidator.publicIsValidSignature.callAsync(
                     orderHashHex,
                     signedOrder.makerAddress,
@@ -155,7 +173,7 @@ describe('MixinSignatureValidator', () => {
             const signatureBuffer = Buffer.concat([fillerData, signatureType]);
             const signatureHex = ethUtil.bufferToHex(signatureBuffer);
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 signatureValidator.publicIsValidSignature.callAsync(
                     orderHashHex,
                     signedOrder.makerAddress,
@@ -213,7 +231,10 @@ describe('MixinSignatureValidator', () => {
         it('should return true when SignatureType=EthSign and signature is valid', async () => {
             // Create EthSign signature
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const orderHashWithEthSignPrefixHex = addSignedMessagePrefix(orderHashHex, SignerType.Default);
+            const orderHashWithEthSignPrefixHex = signatureUtils.addSignedMessagePrefix(
+                orderHashHex,
+                SignerType.Default,
+            );
             const orderHashWithEthSignPrefixBuffer = ethUtil.toBuffer(orderHashWithEthSignPrefixHex);
             const ecSignature = ethUtil.ecsign(orderHashWithEthSignPrefixBuffer, signerPrivateKey);
             // Create 0x signature from EthSign signature
@@ -236,7 +257,10 @@ describe('MixinSignatureValidator', () => {
         it('should return false when SignatureType=EthSign and signature is invalid', async () => {
             // Create EthSign signature
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const orderHashWithEthSignPrefixHex = addSignedMessagePrefix(orderHashHex, SignerType.Default);
+            const orderHashWithEthSignPrefixHex = signatureUtils.addSignedMessagePrefix(
+                orderHashHex,
+                SignerType.Default,
+            );
             const orderHashWithEthSignPrefixBuffer = ethUtil.toBuffer(orderHashWithEthSignPrefixHex);
             const ecSignature = ethUtil.ecsign(orderHashWithEthSignPrefixBuffer, signerPrivateKey);
             // Create 0x signature from EthSign signature
@@ -257,32 +281,6 @@ describe('MixinSignatureValidator', () => {
             expect(isValidSignature).to.be.false();
         });
 
-        it('should return true when SignatureType=Caller and signer is caller', async () => {
-            const signature = ethUtil.toBuffer(`0x${SignatureType.Caller}`);
-            const signatureHex = ethUtil.bufferToHex(signature);
-            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
-                orderHashHex,
-                signerAddress,
-                signatureHex,
-                { from: signerAddress },
-            );
-            expect(isValidSignature).to.be.true();
-        });
-
-        it('should return false when SignatureType=Caller and signer is not caller', async () => {
-            const signature = ethUtil.toBuffer(`0x${SignatureType.Caller}`);
-            const signatureHex = ethUtil.bufferToHex(signature);
-            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
-                orderHashHex,
-                signerAddress,
-                signatureHex,
-                { from: notSignerAddress },
-            );
-            expect(isValidSignature).to.be.false();
-        });
-
         it('should return true when SignatureType=Wallet and signature is valid', async () => {
             // Create EIP712 signature
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
@@ -328,6 +326,29 @@ describe('MixinSignatureValidator', () => {
             expect(isValidSignature).to.be.false();
         });
 
+        it('should revert when `isValidSignature` attempts to update state and SignatureType=Wallet', async () => {
+            // Create EIP712 signature
+            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
+            const orderHashBuffer = ethUtil.toBuffer(orderHashHex);
+            const ecSignature = ethUtil.ecsign(orderHashBuffer, signerPrivateKey);
+            // Create 0x signature from EIP712 signature
+            const signature = Buffer.concat([
+                ethUtil.toBuffer(ecSignature.v),
+                ecSignature.r,
+                ecSignature.s,
+                ethUtil.toBuffer(`0x${SignatureType.Wallet}`),
+            ]);
+            const signatureHex = ethUtil.bufferToHex(signature);
+            await expectContractCallFailedAsync(
+                signatureValidator.publicIsValidSignature.callAsync(
+                    orderHashHex,
+                    maliciousWallet.address,
+                    signatureHex,
+                ),
+                RevertReason.WalletError,
+            );
+        });
+
         it('should return true when SignatureType=Validator, signature is valid and validator is approved', async () => {
             const validatorAddress = ethUtil.toBuffer(`${testValidator.address}`);
             const signatureType = ethUtil.toBuffer(`0x${SignatureType.Validator}`);
@@ -358,6 +379,17 @@ describe('MixinSignatureValidator', () => {
             expect(isValidSignature).to.be.false();
         });
 
+        it('should revert when `isValidSignature` attempts to update state and SignatureType=Validator', async () => {
+            const validatorAddress = ethUtil.toBuffer(`${maliciousValidator.address}`);
+            const signatureType = ethUtil.toBuffer(`0x${SignatureType.Validator}`);
+            const signature = Buffer.concat([validatorAddress, signatureType]);
+            const signatureHex = ethUtil.bufferToHex(signature);
+            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
+            await expectContractCallFailedAsync(
+                signatureValidator.publicIsValidSignature.callAsync(orderHashHex, signerAddress, signatureHex),
+                RevertReason.ValidatorError,
+            );
+        });
         it('should return false when SignatureType=Validator, signature is valid and validator is not approved', async () => {
             // Set approval of signature validator to false
             await web3Wrapper.awaitTransactionSuccessAsync(
@@ -382,53 +414,6 @@ describe('MixinSignatureValidator', () => {
             expect(isValidSignature).to.be.false();
         });
 
-        it('should return true when SignatureType=Trezor and signature is valid', async () => {
-            // Create Trezor signature
-            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const orderHashWithTrezorPrefixHex = addSignedMessagePrefix(orderHashHex, SignerType.Trezor);
-            const orderHashWithTrezorPrefixBuffer = ethUtil.toBuffer(orderHashWithTrezorPrefixHex);
-            const ecSignature = ethUtil.ecsign(orderHashWithTrezorPrefixBuffer, signerPrivateKey);
-            // Create 0x signature from Trezor signature
-            const signature = Buffer.concat([
-                ethUtil.toBuffer(ecSignature.v),
-                ecSignature.r,
-                ecSignature.s,
-                ethUtil.toBuffer(`0x${SignatureType.Trezor}`),
-            ]);
-            const signatureHex = ethUtil.bufferToHex(signature);
-            // Validate signature
-            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
-                orderHashHex,
-                signerAddress,
-                signatureHex,
-            );
-            expect(isValidSignature).to.be.true();
-        });
-
-        it('should return false when SignatureType=Trezor and signature is invalid', async () => {
-            // Create Trezor signature
-            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
-            const orderHashWithTrezorPrefixHex = addSignedMessagePrefix(orderHashHex, SignerType.Trezor);
-            const orderHashWithTrezorPrefixBuffer = ethUtil.toBuffer(orderHashWithTrezorPrefixHex);
-            const ecSignature = ethUtil.ecsign(orderHashWithTrezorPrefixBuffer, signerPrivateKey);
-            // Create 0x signature from Trezor signature
-            const signature = Buffer.concat([
-                ethUtil.toBuffer(ecSignature.v),
-                ecSignature.r,
-                ecSignature.s,
-                ethUtil.toBuffer(`0x${SignatureType.Trezor}`),
-            ]);
-            const signatureHex = ethUtil.bufferToHex(signature);
-            // Validate signature.
-            // This will fail because `signerAddress` signed the message, but we're passing in `notSignerAddress`
-            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
-                orderHashHex,
-                notSignerAddress,
-                signatureHex,
-            );
-            expect(isValidSignature).to.be.false();
-        });
-
         it('should return true when SignatureType=Presigned and signer has presigned hash', async () => {
             // Presign hash
             const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
@@ -462,6 +447,42 @@ describe('MixinSignatureValidator', () => {
             );
             expect(isValidSignature).to.be.false();
         });
+
+        it('should return true when message was signed by a Trezor One (firmware version 1.6.2)', async () => {
+            // messageHash translates to 0x2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b
+            const messageHash = ethUtil.bufferToHex(ethUtil.toBuffer('++++++++++++++++++++++++++++++++'));
+            const signer = '0xc28b145f10f0bcf0fc000e778615f8fd73490bad';
+            const v = ethUtil.toBuffer('0x1c');
+            const r = ethUtil.toBuffer('0x7b888b596ccf87f0bacab0dcb483124973f7420f169b4824d7a12534ac1e9832');
+            const s = ethUtil.toBuffer('0x0c8e14f7edc01459e13965f1da56e0c23ed11e2cca932571eee1292178f90424');
+            const trezorSignatureType = ethUtil.toBuffer(`0x${SignatureType.EthSign}`);
+            const signature = Buffer.concat([v, r, s, trezorSignatureType]);
+            const signatureHex = ethUtil.bufferToHex(signature);
+            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
+                messageHash,
+                signer,
+                signatureHex,
+            );
+            expect(isValidSignature).to.be.true();
+        });
+
+        it('should return true when message was signed by a Trezor Model T (firmware version 2.0.7)', async () => {
+            // messageHash translates to 0x2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b
+            const messageHash = ethUtil.bufferToHex(ethUtil.toBuffer('++++++++++++++++++++++++++++++++'));
+            const signer = '0x98ce6d9345e8ffa7d99ee0822272fae9d2c0e895';
+            const v = ethUtil.toBuffer('0x1c');
+            const r = ethUtil.toBuffer('0x423b71062c327f0ec4fe199b8da0f34185e59b4c1cb4cc23df86cac4a601fb3f');
+            const s = ethUtil.toBuffer('0x53810d6591b5348b7ee08ee812c874b0fdfb942c9849d59512c90e295221091f');
+            const trezorSignatureType = ethUtil.toBuffer(`0x${SignatureType.EthSign}`);
+            const signature = Buffer.concat([v, r, s, trezorSignatureType]);
+            const signatureHex = ethUtil.bufferToHex(signature);
+            const isValidSignature = await signatureValidator.publicIsValidSignature.callAsync(
+                messageHash,
+                signer,
+                signatureHex,
+            );
+            expect(isValidSignature).to.be.true();
+        });
     });
 
     describe('setSignatureValidatorApproval', () => {
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index d48441dca..aadb5ab59 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -11,6 +11,7 @@ import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dumm
 import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
 import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
 import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { ReentrantERC20TokenContract } from '../../generated_contract_wrappers/reentrant_erc20_token';
 import { artifacts } from '../utils/artifacts';
 import { expectTransactionFailedAsync } from '../utils/assertions';
 import { getLatestBlockTimestampAsync, increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
@@ -40,6 +41,7 @@ describe('Exchange wrappers', () => {
     let exchange: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
+    let reentrantErc20Token: ReentrantERC20TokenContract;
 
     let exchangeWrapper: ExchangeWrapper;
     let erc20Wrapper: ERC20Wrapper;
@@ -104,6 +106,13 @@ describe('Exchange wrappers', () => {
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
+        reentrantErc20Token = await ReentrantERC20TokenContract.deployFrom0xArtifactAsync(
+            artifacts.ReentrantERC20Token,
+            provider,
+            txDefaults,
+            exchange.address,
+        );
+
         defaultMakerAssetAddress = erc20TokenA.address;
         defaultTakerAssetAddress = erc20TokenB.address;
 
@@ -126,6 +135,26 @@ describe('Exchange wrappers', () => {
         await blockchainLifecycle.revertAsync();
     });
     describe('fillOrKillOrder', () => {
+        const reentrancyTest = (functionNames: string[]) => {
+            _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                const description = `should not allow fillOrKillOrder to reenter the Exchange contract via ${functionName}`;
+                it(description, async () => {
+                    const signedOrder = await orderFactory.newSignedOrderAsync({
+                        makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                    });
+                    await web3Wrapper.awaitTransactionSuccessAsync(
+                        await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                        constants.AWAIT_TRANSACTION_MINED_MS,
+                    );
+                    await expectTransactionFailedAsync(
+                        exchangeWrapper.fillOrKillOrderAsync(signedOrder, takerAddress),
+                        RevertReason.TransferFailed,
+                    );
+                });
+            });
+        };
+        describe('fillOrKillOrder reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
         it('should transfer the correct amounts', async () => {
             const signedOrder = await orderFactory.newSignedOrderAsync({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
@@ -197,6 +226,25 @@ describe('Exchange wrappers', () => {
     });
 
     describe('fillOrderNoThrow', () => {
+        const reentrancyTest = (functionNames: string[]) => {
+            _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                const description = `should not allow fillOrderNoThrow to reenter the Exchange contract via ${functionName}`;
+                it(description, async () => {
+                    const signedOrder = await orderFactory.newSignedOrderAsync({
+                        makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                    });
+                    await web3Wrapper.awaitTransactionSuccessAsync(
+                        await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                        constants.AWAIT_TRANSACTION_MINED_MS,
+                    );
+                    await exchangeWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
+                    const newBalances = await erc20Wrapper.getBalancesAsync();
+                    expect(erc20Balances).to.deep.equal(newBalances);
+                });
+            });
+        };
+        describe('fillOrderNoThrow reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
         it('should transfer the correct amounts', async () => {
             const signedOrder = await orderFactory.newSignedOrderAsync({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
@@ -397,6 +445,26 @@ describe('Exchange wrappers', () => {
         });
 
         describe('batchFillOrders', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow batchFillOrders to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await expectTransactionFailedAsync(
+                            exchangeWrapper.batchFillOrdersAsync([signedOrder], takerAddress),
+                            RevertReason.TransferFailed,
+                        );
+                    });
+                });
+            };
+            describe('batchFillOrders reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should transfer the correct amounts', async () => {
                 const takerAssetFillAmounts: BigNumber[] = [];
                 const makerAssetAddress = erc20TokenA.address;
@@ -446,6 +514,26 @@ describe('Exchange wrappers', () => {
         });
 
         describe('batchFillOrKillOrders', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow batchFillOrKillOrders to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await expectTransactionFailedAsync(
+                            exchangeWrapper.batchFillOrKillOrdersAsync([signedOrder], takerAddress),
+                            RevertReason.TransferFailed,
+                        );
+                    });
+                });
+            };
+            describe('batchFillOrKillOrders reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should transfer the correct amounts', async () => {
                 const takerAssetFillAmounts: BigNumber[] = [];
                 const makerAssetAddress = erc20TokenA.address;
@@ -512,6 +600,25 @@ describe('Exchange wrappers', () => {
         });
 
         describe('batchFillOrdersNoThrow', async () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow batchFillOrdersNoThrow to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await exchangeWrapper.batchFillOrdersNoThrowAsync([signedOrder], takerAddress);
+                        const newBalances = await erc20Wrapper.getBalancesAsync();
+                        expect(erc20Balances).to.deep.equal(newBalances);
+                    });
+                });
+            };
+            describe('batchFillOrdersNoThrow reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should transfer the correct amounts', async () => {
                 const takerAssetFillAmounts: BigNumber[] = [];
                 const makerAssetAddress = erc20TokenA.address;
@@ -625,6 +732,28 @@ describe('Exchange wrappers', () => {
         });
 
         describe('marketSellOrders', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow marketSellOrders to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await expectTransactionFailedAsync(
+                            exchangeWrapper.marketSellOrdersAsync([signedOrder], takerAddress, {
+                                takerAssetFillAmount: signedOrder.takerAssetAmount,
+                            }),
+                            RevertReason.TransferFailed,
+                        );
+                    });
+                });
+            };
+            describe('marketSellOrders reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should stop when the entire takerAssetFillAmount is filled', async () => {
                 const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus(
                     signedOrders[1].takerAssetAmount.div(2),
@@ -717,6 +846,27 @@ describe('Exchange wrappers', () => {
         });
 
         describe('marketSellOrdersNoThrow', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow marketSellOrdersNoThrow to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await exchangeWrapper.marketSellOrdersNoThrowAsync([signedOrder], takerAddress, {
+                            takerAssetFillAmount: signedOrder.takerAssetAmount,
+                        });
+                        const newBalances = await erc20Wrapper.getBalancesAsync();
+                        expect(erc20Balances).to.deep.equal(newBalances);
+                    });
+                });
+            };
+            describe('marketSellOrdersNoThrow reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should stop when the entire takerAssetFillAmount is filled', async () => {
                 const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus(
                     signedOrders[1].takerAssetAmount.div(2),
@@ -843,6 +993,28 @@ describe('Exchange wrappers', () => {
         });
 
         describe('marketBuyOrders', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow marketBuyOrders to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await expectTransactionFailedAsync(
+                            exchangeWrapper.marketBuyOrdersAsync([signedOrder], takerAddress, {
+                                makerAssetFillAmount: signedOrder.makerAssetAmount,
+                            }),
+                            RevertReason.TransferFailed,
+                        );
+                    });
+                });
+            };
+            describe('marketBuyOrders reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should stop when the entire makerAssetFillAmount is filled', async () => {
                 const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus(
                     signedOrders[1].makerAssetAmount.div(2),
@@ -933,6 +1105,27 @@ describe('Exchange wrappers', () => {
         });
 
         describe('marketBuyOrdersNoThrow', () => {
+            const reentrancyTest = (functionNames: string[]) => {
+                _.forEach(functionNames, async (functionName: string, functionId: number) => {
+                    const description = `should not allow marketBuyOrdersNoThrow to reenter the Exchange contract via ${functionName}`;
+                    it(description, async () => {
+                        const signedOrder = await orderFactory.newSignedOrderAsync({
+                            makerAssetData: assetDataUtils.encodeERC20AssetData(reentrantErc20Token.address),
+                        });
+                        await web3Wrapper.awaitTransactionSuccessAsync(
+                            await reentrantErc20Token.setCurrentFunction.sendTransactionAsync(functionId),
+                            constants.AWAIT_TRANSACTION_MINED_MS,
+                        );
+                        await exchangeWrapper.marketBuyOrdersNoThrowAsync([signedOrder], takerAddress, {
+                            makerAssetFillAmount: signedOrder.makerAssetAmount,
+                        });
+                        const newBalances = await erc20Wrapper.getBalancesAsync();
+                        expect(erc20Balances).to.deep.equal(newBalances);
+                    });
+                });
+            };
+            describe('marketBuyOrdersNoThrow reentrancy tests', () => reentrancyTest(constants.FUNCTIONS_WITH_MUTEX));
+
             it('should stop when the entire makerAssetFillAmount is filled', async () => {
                 const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus(
                     signedOrders[1].makerAssetAmount.div(2),
diff --git a/packages/contracts/test/forwarder/forwarder.ts b/packages/contracts/test/extensions/forwarder.ts
index 28ffdeabe..8424d01fd 100644
--- a/packages/contracts/test/forwarder/forwarder.ts
+++ b/packages/contracts/test/extensions/forwarder.ts
@@ -12,7 +12,11 @@ import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
 import { ForwarderContract } from '../../generated_contract_wrappers/forwarder';
 import { WETH9Contract } from '../../generated_contract_wrappers/weth9';
 import { artifacts } from '../utils/artifacts';
-import { expectTransactionFailedAsync } from '../utils/assertions';
+import {
+    expectContractCreationFailedAsync,
+    expectTransactionFailedAsync,
+    sendTransactionResult,
+} from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { ERC20Wrapper } from '../utils/erc20_wrapper';
@@ -37,6 +41,7 @@ describe(ContractName.Forwarder, () => {
     let otherAddress: string;
     let defaultMakerAssetAddress: string;
     let zrxAssetData: string;
+    let wethAssetData: string;
 
     let weth: DummyERC20TokenContract;
     let zrxToken: DummyERC20TokenContract;
@@ -90,7 +95,7 @@ describe(ContractName.Forwarder, () => {
         weth = new DummyERC20TokenContract(wethContract.abi, wethContract.address, provider);
         erc20Wrapper.addDummyTokenContract(weth);
 
-        const wethAssetData = assetDataUtils.encodeERC20AssetData(wethContract.address);
+        wethAssetData = assetDataUtils.encodeERC20AssetData(wethContract.address);
         zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
         const exchangeInstance = await ExchangeContract.deployFrom0xArtifactAsync(
             artifacts.Exchange,
@@ -98,8 +103,7 @@ describe(ContractName.Forwarder, () => {
             txDefaults,
             zrxAssetData,
         );
-        const exchangeContract = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
-        exchangeWrapper = new ExchangeWrapper(exchangeContract, provider);
+        exchangeWrapper = new ExchangeWrapper(exchangeInstance, provider);
         await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
         await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
 
@@ -131,8 +135,6 @@ describe(ContractName.Forwarder, () => {
             provider,
             txDefaults,
             exchangeInstance.address,
-            wethContract.address,
-            zrxToken.address,
             zrxAssetData,
             wethAssetData,
         );
@@ -164,6 +166,27 @@ describe(ContractName.Forwarder, () => {
         await blockchainLifecycle.revertAsync();
     });
 
+    describe('constructor', () => {
+        it('should revert if assetProxy is unregistered', async () => {
+            const exchangeInstance = await ExchangeContract.deployFrom0xArtifactAsync(
+                artifacts.Exchange,
+                provider,
+                txDefaults,
+                zrxAssetData,
+            );
+            return expectContractCreationFailedAsync(
+                (ForwarderContract.deployFrom0xArtifactAsync(
+                    artifacts.Forwarder,
+                    provider,
+                    txDefaults,
+                    exchangeInstance.address,
+                    zrxAssetData,
+                    wethAssetData,
+                ) as any) as sendTransactionResult,
+                RevertReason.UnregisteredAssetProxy,
+            );
+        });
+    });
     describe('marketSellOrdersWithEth without extra fees', () => {
         it('should fill a single order', async () => {
             const ordersWithoutFee = [orderWithoutFee];
diff --git a/packages/contracts/test/extensions/order_validator.ts b/packages/contracts/test/extensions/order_validator.ts
new file mode 100644
index 000000000..3a57cfc37
--- /dev/null
+++ b/packages/contracts/test/extensions/order_validator.ts
@@ -0,0 +1,600 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { assetDataUtils, orderHashUtils } from '@0xproject/order-utils';
+import { SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
+import * as _ from 'lodash';
+
+import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
+import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_erc721_token';
+import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
+import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
+import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { OrderValidatorContract } from '../../generated_contract_wrappers/order_validator';
+import { artifacts } from '../utils/artifacts';
+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 { OrderStatus } from '../utils/types';
+import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('OrderValidator', () => {
+    let makerAddress: string;
+    let owner: string;
+    let takerAddress: string;
+    let erc20AssetData: string;
+    let erc721AssetData: string;
+
+    let erc20Token: DummyERC20TokenContract;
+    let zrxToken: DummyERC20TokenContract;
+    let erc721Token: DummyERC721TokenContract;
+    let exchange: ExchangeContract;
+    let orderValidator: OrderValidatorContract;
+    let erc20Proxy: ERC20ProxyContract;
+    let erc721Proxy: ERC721ProxyContract;
+
+    let signedOrder: SignedOrder;
+    let signedOrder2: SignedOrder;
+    let orderFactory: OrderFactory;
+
+    const tokenId = new BigNumber(123456789);
+    const tokenId2 = new BigNumber(987654321);
+    const ERC721_BALANCE = new BigNumber(1);
+    const ERC721_ALLOWANCE = new BigNumber(1);
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        const usedAddresses = ([owner, makerAddress, takerAddress] = _.slice(accounts, 0, 3));
+
+        const erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
+        const erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
+
+        const numDummyErc20ToDeploy = 2;
+        [erc20Token, zrxToken] = await erc20Wrapper.deployDummyTokensAsync(
+            numDummyErc20ToDeploy,
+            constants.DUMMY_TOKEN_DECIMALS,
+        );
+        erc20Proxy = await erc20Wrapper.deployProxyAsync();
+
+        [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
+        erc721Proxy = await erc721Wrapper.deployProxyAsync();
+
+        const zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            artifacts.Exchange,
+            provider,
+            txDefaults,
+            zrxAssetData,
+        );
+        const exchangeWrapper = new ExchangeWrapper(exchange, provider);
+        await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
+        await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
+
+        orderValidator = await OrderValidatorContract.deployFrom0xArtifactAsync(
+            artifacts.OrderValidator,
+            provider,
+            txDefaults,
+            exchange.address,
+            zrxAssetData,
+        );
+
+        erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+        erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId);
+        const defaultOrderParams = {
+            ...constants.STATIC_ORDER_PARAMS,
+            exchangeAddress: exchange.address,
+            makerAddress,
+            feeRecipientAddress: constants.NULL_ADDRESS,
+            makerAssetData: erc20AssetData,
+            takerAssetData: erc721AssetData,
+        };
+        const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        orderFactory = new OrderFactory(privateKey, defaultOrderParams);
+    });
+
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('getBalanceAndAllowance', () => {
+        describe('getERC721TokenOwner', async () => {
+            it('should return the null address when tokenId is not owned', async () => {
+                const tokenOwner = await orderValidator.getERC721TokenOwner.callAsync(makerAddress, tokenId);
+                expect(tokenOwner).to.be.equal(constants.NULL_ADDRESS);
+            });
+            it('should return the owner address when tokenId is owned', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const tokenOwner = await orderValidator.getERC721TokenOwner.callAsync(erc721Token.address, tokenId);
+                expect(tokenOwner).to.be.equal(makerAddress);
+            });
+        });
+        describe('ERC20 assetData', () => {
+            it('should return the correct balances and allowances when both values are 0', async () => {
+                const [newBalance, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc20AssetData,
+                );
+                expect(constants.ZERO_AMOUNT).to.be.bignumber.equal(newBalance);
+                expect(constants.ZERO_AMOUNT).to.be.bignumber.equal(newAllowance);
+            });
+            it('should return the correct balance and allowance when both values are non-zero', async () => {
+                const balance = new BigNumber(123);
+                const allowance = new BigNumber(456);
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc20Token.setBalance.sendTransactionAsync(makerAddress, balance),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [newBalance, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc20AssetData,
+                );
+                expect(balance).to.be.bignumber.equal(newBalance);
+                expect(allowance).to.be.bignumber.equal(newAllowance);
+            });
+        });
+        describe('ERC721 assetData', () => {
+            it('should return a balance of 0 when the tokenId is not owned by target', async () => {
+                const [newBalance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            });
+            it('should return an allowance of 0 when no approval is set', async () => {
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            });
+            it('should return a balance of 1 when the tokenId is owned by target', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [newBalance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            });
+            it('should return an allowance of 1 when ERC721Proxy is approved for all', async () => {
+                const isApproved = true;
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            });
+            it('should return an allowance of 1 when ERC721Proxy is approved for specific tokenId', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            });
+        });
+    });
+    describe('getBalancesAndAllowances', () => {
+        it('should return the correct balances and allowances when all values are 0', async () => {
+            const [
+                [erc20Balance, erc721Balance],
+                [erc20Allowance, erc721Allowance],
+            ] = await orderValidator.getBalancesAndAllowances.callAsync(makerAddress, [
+                erc20AssetData,
+                erc721AssetData,
+            ]);
+            expect(erc20Balance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc721Balance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc20Allowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc721Allowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct balances and allowances when balances and allowances are non-zero', async () => {
+            const balance = new BigNumber(123);
+            const allowance = new BigNumber(456);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, balance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const [
+                [erc20Balance, erc721Balance],
+                [erc20Allowance, erc721Allowance],
+            ] = await orderValidator.getBalancesAndAllowances.callAsync(makerAddress, [
+                erc20AssetData,
+                erc721AssetData,
+            ]);
+            expect(erc20Balance).to.be.bignumber.equal(balance);
+            expect(erc721Balance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(erc20Allowance).to.be.bignumber.equal(allowance);
+            expect(erc721Allowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+        });
+    });
+    describe('getTraderInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct info when no balances or allowances are set', async () => {
+            const traderInfo = await orderValidator.getTraderInfo.callAsync(signedOrder, takerAddress);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const traderInfo = await orderValidator.getTraderInfo.callAsync(signedOrder, takerAddress);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getTradersInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+            signedOrder2 = await orderFactory.newSignedOrderAsync({
+                takerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId2),
+            });
+        });
+        it('should return the correct info when no balances or allowances have been set', async () => {
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [traderInfo1, traderInfo2] = await orderValidator.getTradersInfo.callAsync(orders, takers);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId2),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [traderInfo1, traderInfo2] = await orderValidator.getTradersInfo.callAsync(orders, takers);
+
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getOrderAndTraderInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct info when no balances or allowances are set', async () => {
+            const [orderInfo, traderInfo] = await orderValidator.getOrderAndTraderInfo.callAsync(
+                signedOrder,
+                takerAddress,
+            );
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const [orderInfo, traderInfo] = await orderValidator.getOrderAndTraderInfo.callAsync(
+                signedOrder,
+                takerAddress,
+            );
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getOrdersAndTradersInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+            signedOrder2 = await orderFactory.newSignedOrderAsync({
+                takerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId2),
+            });
+        });
+        it('should return the correct info when no balances or allowances have been set', async () => {
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [
+                [orderInfo1, orderInfo2],
+                [traderInfo1, traderInfo2],
+            ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
+            const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
+            expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
+            expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
+            expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId2),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [
+                [orderInfo1, orderInfo2],
+                [traderInfo1, traderInfo2],
+            ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
+            const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
+            expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
+            expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
+            expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+});
+// tslint:disable:max-file-line-count
diff --git a/packages/contracts/test/libraries/lib_bytes.ts b/packages/contracts/test/libraries/lib_bytes.ts
index 1c497a226..13640a761 100644
--- a/packages/contracts/test/libraries/lib_bytes.ts
+++ b/packages/contracts/test/libraries/lib_bytes.ts
@@ -9,7 +9,7 @@ import * as _ from 'lodash';
 
 import { TestLibBytesContract } from '../../generated_contract_wrappers/test_lib_bytes';
 import { artifacts } from '../utils/artifacts';
-import { expectContractCallFailed } from '../utils/assertions';
+import { expectContractCallFailedAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { typeEncodingUtils } from '../utils/type_encoding_utils';
@@ -41,6 +41,8 @@ describe('LibBytes', () => {
     const testBytes32B = '0x534877abd8443578526845cdfef020047528759477fedef87346527659aced32';
     const testUint256 = new BigNumber(testBytes32, 16);
     const testUint256B = new BigNumber(testBytes32B, 16);
+    const testBytes4 = '0xabcdef12';
+    const testByte = '0xab';
     let shortData: string;
     let shortTestBytes: string;
     let shortTestBytesAsBuffer: Buffer;
@@ -101,34 +103,47 @@ describe('LibBytes', () => {
 
     describe('popLastByte', () => {
         it('should revert if length is 0', async () => {
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicPopLastByte.callAsync(constants.NULL_BYTES),
                 RevertReason.LibBytesGreaterThanZeroLengthRequired,
             );
         });
-        it('should pop the last byte from the input and return it', async () => {
+        it('should pop the last byte from the input and return it when array holds more than 1 byte', async () => {
             const [newBytes, poppedByte] = await libBytes.publicPopLastByte.callAsync(byteArrayLongerThan32Bytes);
             const expectedNewBytes = byteArrayLongerThan32Bytes.slice(0, -2);
             const expectedPoppedByte = `0x${byteArrayLongerThan32Bytes.slice(-2)}`;
             expect(newBytes).to.equal(expectedNewBytes);
             expect(poppedByte).to.equal(expectedPoppedByte);
         });
+        it('should pop the last byte from the input and return it when array is exactly 1 byte', async () => {
+            const [newBytes, poppedByte] = await libBytes.publicPopLastByte.callAsync(testByte);
+            const expectedNewBytes = '0x';
+            expect(newBytes).to.equal(expectedNewBytes);
+            return expect(poppedByte).to.be.equal(testByte);
+        });
     });
 
     describe('popLast20Bytes', () => {
         it('should revert if length is less than 20', async () => {
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicPopLast20Bytes.callAsync(byteArrayShorterThan20Bytes),
                 RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
             );
         });
-        it('should pop the last 20 bytes from the input and return it', async () => {
+        it('should pop the last 20 bytes from the input and return it when array holds more than 20 bytes', async () => {
             const [newBytes, poppedAddress] = await libBytes.publicPopLast20Bytes.callAsync(byteArrayLongerThan32Bytes);
             const expectedNewBytes = byteArrayLongerThan32Bytes.slice(0, -40);
             const expectedPoppedAddress = `0x${byteArrayLongerThan32Bytes.slice(-40)}`;
             expect(newBytes).to.equal(expectedNewBytes);
             expect(poppedAddress).to.equal(expectedPoppedAddress);
         });
+        it('should pop the last 20 bytes from the input and return it when array is exactly 20 bytes', async () => {
+            const [newBytes, poppedAddress] = await libBytes.publicPopLast20Bytes.callAsync(testAddress);
+            const expectedNewBytes = '0x';
+            const expectedPoppedAddress = testAddress;
+            expect(newBytes).to.equal(expectedNewBytes);
+            expect(poppedAddress).to.equal(expectedPoppedAddress);
+        });
     });
 
     describe('equals', () => {
@@ -185,7 +200,7 @@ describe('LibBytes', () => {
 
     describe('deepCopyBytes', () => {
         it('should revert if dest is shorter than source', async () => {
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicDeepCopyBytes.callAsync(byteArrayShorterThan32Bytes, byteArrayLongerThan32Bytes),
                 RevertReason.LibBytesGreaterOrEqualToSourceBytesLengthRequired,
             );
@@ -238,7 +253,7 @@ describe('LibBytes', () => {
         it('should fail if the byte array is too short to hold an address', async () => {
             const shortByteArray = '0xabcdef';
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadAddress.callAsync(shortByteArray, offset),
                 RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
             );
@@ -246,7 +261,7 @@ describe('LibBytes', () => {
         it('should fail if the length between the offset and end of the byte array is too short to hold an address', async () => {
             const byteArray = testAddress;
             const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadAddress.callAsync(byteArray, badOffset),
                 RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
             );
@@ -282,7 +297,7 @@ describe('LibBytes', () => {
         });
         it('should fail if the byte array is too short to hold an address', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteAddress.callAsync(byteArrayShorterThan20Bytes, offset, testAddress),
                 RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
             );
@@ -290,7 +305,7 @@ describe('LibBytes', () => {
         it('should fail if the length between the offset and end of the byte array is too short to hold an address', async () => {
             const byteArray = byteArrayLongerThan32Bytes;
             const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteAddress.callAsync(byteArray, badOffset, testAddress),
                 RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
             );
@@ -303,7 +318,7 @@ describe('LibBytes', () => {
             const bytes32 = await libBytes.publicReadBytes32.callAsync(testBytes32, testBytes32Offset);
             return expect(bytes32).to.be.equal(testBytes32);
         });
-        it('should successfully read bytes32 when it is offset in the array)', async () => {
+        it('should successfully read bytes32 when it is offset in the array', async () => {
             const bytes32ByteArrayBuffer = ethUtil.toBuffer(testBytes32);
             const prefixByteArrayBuffer = ethUtil.toBuffer('0xabcdef');
             const combinedByteArrayBuffer = Buffer.concat([prefixByteArrayBuffer, bytes32ByteArrayBuffer]);
@@ -314,14 +329,14 @@ describe('LibBytes', () => {
         });
         it('should fail if the byte array is too short to hold a bytes32', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytes32.callAsync(byteArrayShorterThan32Bytes, offset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
         });
         it('should fail if the length between the offset and end of the byte array is too short to hold a bytes32', async () => {
             const badOffset = new BigNumber(ethUtil.toBuffer(testBytes32).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytes32.callAsync(testBytes32, badOffset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -357,7 +372,7 @@ describe('LibBytes', () => {
         });
         it('should fail if the byte array is too short to hold a bytes32', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteBytes32.callAsync(byteArrayShorterThan32Bytes, offset, testBytes32),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -365,7 +380,7 @@ describe('LibBytes', () => {
         it('should fail if the length between the offset and end of the byte array is too short to hold a bytes32', async () => {
             const byteArray = byteArrayLongerThan32Bytes;
             const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteBytes32.callAsync(byteArray, badOffset, testBytes32),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -393,7 +408,7 @@ describe('LibBytes', () => {
         });
         it('should fail if the byte array is too short to hold a uint256', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadUint256.callAsync(byteArrayShorterThan32Bytes, offset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -403,7 +418,7 @@ describe('LibBytes', () => {
             const testUint256AsBuffer = ethUtil.toBuffer(formattedTestUint256);
             const byteArray = ethUtil.bufferToHex(testUint256AsBuffer);
             const badOffset = new BigNumber(testUint256AsBuffer.byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadUint256.callAsync(byteArray, badOffset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -443,7 +458,7 @@ describe('LibBytes', () => {
         });
         it('should fail if the byte array is too short to hold a uint256', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteUint256.callAsync(byteArrayShorterThan32Bytes, offset, testUint256),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -451,7 +466,7 @@ describe('LibBytes', () => {
         it('should fail if the length between the offset and end of the byte array is too short to hold a uint256', async () => {
             const byteArray = byteArrayLongerThan32Bytes;
             const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteUint256.callAsync(byteArray, badOffset, testUint256),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -462,8 +477,9 @@ describe('LibBytes', () => {
         // AssertionError: expected promise to be rejected with an error including 'revert' but it was fulfilled with '0x08c379a0'
         it('should revert if byte array has a length < 4', async () => {
             const byteArrayLessThan4Bytes = '0x010101';
-            return expectContractCallFailed(
-                libBytes.publicReadBytes4.callAsync(byteArrayLessThan4Bytes, new BigNumber(0)),
+            const offset = new BigNumber(0);
+            return expectContractCallFailedAsync(
+                libBytes.publicReadBytes4.callAsync(byteArrayLessThan4Bytes, offset),
                 RevertReason.LibBytesGreaterOrEqualTo4LengthRequired,
             );
         });
@@ -472,6 +488,27 @@ describe('LibBytes', () => {
             const expectedFirst4Bytes = byteArrayLongerThan32Bytes.slice(0, 10);
             expect(first4Bytes).to.equal(expectedFirst4Bytes);
         });
+        it('should successfully read bytes4 when the bytes4 takes up the whole array', async () => {
+            const testBytes4Offset = new BigNumber(0);
+            const bytes4 = await libBytes.publicReadBytes4.callAsync(testBytes4, testBytes4Offset);
+            return expect(bytes4).to.be.equal(testBytes4);
+        });
+        it('should successfully read bytes4 when it is offset in the array', async () => {
+            const bytes4ByteArrayBuffer = ethUtil.toBuffer(testBytes4);
+            const prefixByteArrayBuffer = ethUtil.toBuffer('0xabcdef');
+            const combinedByteArrayBuffer = Buffer.concat([prefixByteArrayBuffer, bytes4ByteArrayBuffer]);
+            const combinedByteArray = ethUtil.bufferToHex(combinedByteArrayBuffer);
+            const testBytes4Offset = new BigNumber(prefixByteArrayBuffer.byteLength);
+            const bytes4 = await libBytes.publicReadBytes4.callAsync(combinedByteArray, testBytes4Offset);
+            return expect(bytes4).to.be.equal(testBytes4);
+        });
+        it('should fail if the length between the offset and end of the byte array is too short to hold a bytes4', async () => {
+            const badOffset = new BigNumber(ethUtil.toBuffer(testBytes4).byteLength);
+            return expectContractCallFailedAsync(
+                libBytes.publicReadBytes4.callAsync(testBytes4, badOffset),
+                RevertReason.LibBytesGreaterOrEqualTo4LengthRequired,
+            );
+        });
     });
 
     describe('readBytesWithLength', () => {
@@ -517,28 +554,28 @@ describe('LibBytes', () => {
         it('should fail if the byte array is too short to hold the length of a nested byte array', async () => {
             // The length of the nested array is 32 bytes. By storing less than 32 bytes, a length cannot be read.
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytesWithLength.callAsync(byteArrayShorterThan32Bytes, offset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
         });
         it('should fail if we store a nested byte array length, without a nested byte array', async () => {
             const offset = new BigNumber(0);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytesWithLength.callAsync(testBytes32, offset),
                 RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
             );
         });
         it('should fail if the length between the offset and end of the byte array is too short to hold the length of a nested byte array', async () => {
             const badOffset = new BigNumber(ethUtil.toBuffer(byteArrayShorterThan32Bytes).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytesWithLength.callAsync(byteArrayShorterThan32Bytes, badOffset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
         });
         it('should fail if the length between the offset and end of the byte array is too short to hold the nested byte array', async () => {
             const badOffset = new BigNumber(ethUtil.toBuffer(testBytes32).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicReadBytesWithLength.callAsync(testBytes32, badOffset),
                 RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
             );
@@ -546,7 +583,7 @@ describe('LibBytes', () => {
     });
 
     describe('writeBytesWithLength', () => {
-        it('should successfully write short, nested array of bytes when it takes up the whole array)', async () => {
+        it('should successfully write short, nested array of bytes when it takes up the whole array', async () => {
             const testBytesOffset = new BigNumber(0);
             const emptyByteArray = ethUtil.bufferToHex(new Buffer(shortTestBytesAsBuffer.byteLength));
             const bytesWritten = await libBytes.publicWriteBytesWithLength.callAsync(
@@ -650,15 +687,15 @@ describe('LibBytes', () => {
         it('should fail if the byte array is too short to hold the length of a nested byte array', async () => {
             const offset = new BigNumber(0);
             const emptyByteArray = ethUtil.bufferToHex(new Buffer(1));
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteBytesWithLength.callAsync(emptyByteArray, offset, longData),
                 RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
             );
         });
-        it('should fail if the length between the offset and end of the byte array is too short to hold the length of a nested byte array)', async () => {
+        it('should fail if the length between the offset and end of the byte array is too short to hold the length of a nested byte array', async () => {
             const emptyByteArray = ethUtil.bufferToHex(new Buffer(shortTestBytesAsBuffer.byteLength));
             const badOffset = new BigNumber(ethUtil.toBuffer(shortTestBytesAsBuffer).byteLength);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 libBytes.publicWriteBytesWithLength.callAsync(emptyByteArray, badOffset, shortData),
                 RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
             );
diff --git a/packages/contracts/test/multisig/asset_proxy_owner.ts b/packages/contracts/test/multisig/asset_proxy_owner.ts
index 6b98605d3..299707512 100644
--- a/packages/contracts/test/multisig/asset_proxy_owner.ts
+++ b/packages/contracts/test/multisig/asset_proxy_owner.ts
@@ -1,4 +1,5 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { RevertReason } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
@@ -14,9 +15,11 @@ import { MixinAuthorizableContract } from '../../generated_contract_wrappers/mix
 import { TestAssetProxyOwnerContract } from '../../generated_contract_wrappers/test_asset_proxy_owner';
 import { artifacts } from '../utils/artifacts';
 import {
-    expectContractCallFailedWithoutReasonAsync,
-    expectContractCreationFailedWithoutReason,
+    expectContractCallFailedAsync,
+    expectContractCreationFailedAsync,
+    expectTransactionFailedAsync,
     expectTransactionFailedWithoutReasonAsync,
+    sendTransactionResult,
 } from '../utils/assertions';
 import { increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
 import { chaiSetup } from '../utils/chai_setup';
@@ -31,6 +34,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 describe('AssetProxyOwner', () => {
     let owners: string[];
     let authorized: string;
+    let notOwner: string;
     const REQUIRED_APPROVALS = new BigNumber(2);
     const SECONDS_TIME_LOCKED = new BigNumber(1000000);
 
@@ -48,7 +52,9 @@ describe('AssetProxyOwner', () => {
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owners = [accounts[0], accounts[1]];
-        const initialOwner = (authorized = accounts[0]);
+        authorized = accounts[2];
+        notOwner = accounts[3];
+        const initialOwner = accounts[0];
         erc20Proxy = await MixinAuthorizableContract.deployFrom0xArtifactAsync(
             artifacts.MixinAuthorizable,
             provider,
@@ -109,8 +115,8 @@ describe('AssetProxyOwner', () => {
         });
         it('should throw if a null address is included in assetProxyContracts', async () => {
             const assetProxyContractAddresses = [erc20Proxy.address, constants.NULL_ADDRESS];
-            return expectContractCreationFailedWithoutReason(
-                AssetProxyOwnerContract.deployFrom0xArtifactAsync(
+            return expectContractCreationFailedAsync(
+                (AssetProxyOwnerContract.deployFrom0xArtifactAsync(
                     artifacts.AssetProxyOwner,
                     provider,
                     txDefaults,
@@ -118,7 +124,8 @@ describe('AssetProxyOwner', () => {
                     assetProxyContractAddresses,
                     REQUIRED_APPROVALS,
                     SECONDS_TIME_LOCKED,
-                ),
+                ) as any) as sendTransactionResult,
+                RevertReason.InvalidAssetProxy,
             );
         });
     });
@@ -148,25 +155,6 @@ describe('AssetProxyOwner', () => {
         });
     });
 
-    describe('readBytes4', () => {
-        it('should revert if byte array has a length < 4', async () => {
-            const byteArrayLessThan4Bytes = '0x010101';
-            return expectContractCallFailedWithoutReasonAsync(
-                testAssetProxyOwner.publicReadBytes4.callAsync(byteArrayLessThan4Bytes, new BigNumber(0)),
-            );
-        });
-        it('should return the first 4 bytes of a byte array of arbitrary length', async () => {
-            const byteArrayLongerThan32Bytes =
-                '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-            const first4Bytes = await testAssetProxyOwner.publicReadBytes4.callAsync(
-                byteArrayLongerThan32Bytes,
-                new BigNumber(0),
-            );
-            const expectedFirst4Bytes = byteArrayLongerThan32Bytes.slice(0, 10);
-            expect(first4Bytes).to.equal(expectedFirst4Bytes);
-        });
-    });
-
     describe('registerAssetProxy', () => {
         it('should throw if not called by multisig', async () => {
             const isRegistered = true;
@@ -284,8 +272,12 @@ describe('AssetProxyOwner', () => {
             await multiSigWrapper.confirmTransactionAsync(erc721AddAuthorizedAddressTxId, owners[1]);
             await increaseTimeAndMineBlockAsync(SECONDS_TIME_LOCKED.toNumber());
             await multiSigWrapper.executeTransactionAsync(registerAssetProxyTxId, owners[0]);
-            await multiSigWrapper.executeTransactionAsync(erc20AddAuthorizedAddressTxId, owners[0]);
-            await multiSigWrapper.executeTransactionAsync(erc721AddAuthorizedAddressTxId, owners[0]);
+            await multiSigWrapper.executeTransactionAsync(erc20AddAuthorizedAddressTxId, owners[0], {
+                gas: constants.MAX_EXECUTE_TRANSACTION_GAS,
+            });
+            await multiSigWrapper.executeTransactionAsync(erc721AddAuthorizedAddressTxId, owners[0], {
+                gas: constants.MAX_EXECUTE_TRANSACTION_GAS,
+            });
         });
 
         describe('validRemoveAuthorizedAddressAtIndexTx', () => {
@@ -300,8 +292,9 @@ describe('AssetProxyOwner', () => {
                 );
                 const log = submitTxRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
                 const txId = log.args.transactionId;
-                return expectContractCallFailedWithoutReasonAsync(
+                return expectContractCallFailedAsync(
                     testAssetProxyOwner.testValidRemoveAuthorizedAddressAtIndexTx.callAsync(txId),
+                    RevertReason.InvalidFunctionSelector,
                 );
             });
 
@@ -335,8 +328,9 @@ describe('AssetProxyOwner', () => {
                 );
                 const log = submitTxRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
                 const txId = log.args.transactionId;
-                return expectContractCallFailedWithoutReasonAsync(
+                return expectContractCallFailedAsync(
                     testAssetProxyOwner.testValidRemoveAuthorizedAddressAtIndexTx.callAsync(txId),
+                    RevertReason.UnregisteredAssetProxy,
                 );
             });
         });
@@ -355,10 +349,11 @@ describe('AssetProxyOwner', () => {
                 const log = res.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
                 const txId = log.args.transactionId;
 
-                return expectTransactionFailedWithoutReasonAsync(
+                return expectTransactionFailedAsync(
                     testAssetProxyOwner.executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
                         from: owners[1],
                     }),
+                    RevertReason.TxNotFullyConfirmed,
                 );
             });
 
@@ -377,10 +372,11 @@ describe('AssetProxyOwner', () => {
 
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
-                return expectTransactionFailedWithoutReasonAsync(
+                return expectTransactionFailedAsync(
                     testAssetProxyOwner.executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
                         from: owners[1],
                     }),
+                    RevertReason.UnregisteredAssetProxy,
                 );
             });
 
@@ -399,14 +395,18 @@ describe('AssetProxyOwner', () => {
 
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
-                return expectTransactionFailedWithoutReasonAsync(
+                return expectTransactionFailedAsync(
                     testAssetProxyOwner.executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
                         from: owners[1],
                     }),
+                    RevertReason.InvalidFunctionSelector,
                 );
             });
 
-            it('should execute removeAuthorizedAddressAtIndex for registered address if fully confirmed', async () => {
+            it('should execute removeAuthorizedAddressAtIndex for registered address if fully confirmed and called by owner', async () => {
+                const isAuthorizedBefore = await erc20Proxy.authorized.callAsync(authorized);
+                expect(isAuthorizedBefore).to.equal(true);
+
                 const removeAuthorizedAddressAtIndexData = erc20Proxy.removeAuthorizedAddressAtIndex.getABIEncodedTransactionData(
                     authorized,
                     erc20Index,
@@ -422,15 +422,45 @@ describe('AssetProxyOwner', () => {
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
                 const execRes = await multiSigWrapper.executeRemoveAuthorizedAddressAtIndexAsync(txId, owners[0]);
-                const execLog = execRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
+                const execLog = execRes.logs[1] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
+                expect(execLog.args.transactionId).to.be.bignumber.equal(txId);
+
+                const tx = await testAssetProxyOwner.transactions.callAsync(txId);
+                const isExecuted = tx[3];
+                expect(isExecuted).to.equal(true);
+
+                const isAuthorizedAfter = await erc20Proxy.authorized.callAsync(authorized);
+                expect(isAuthorizedAfter).to.equal(false);
+            });
+
+            it('should execute removeAuthorizedAddressAtIndex for registered address if fully confirmed and called by non-owner', async () => {
+                const isAuthorizedBefore = await erc20Proxy.authorized.callAsync(authorized);
+                expect(isAuthorizedBefore).to.equal(true);
+
+                const removeAuthorizedAddressAtIndexData = erc20Proxy.removeAuthorizedAddressAtIndex.getABIEncodedTransactionData(
+                    authorized,
+                    erc20Index,
+                );
+                const submitRes = await multiSigWrapper.submitTransactionAsync(
+                    erc20Proxy.address,
+                    removeAuthorizedAddressAtIndexData,
+                    owners[0],
+                );
+                const submitLog = submitRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
+                const txId = submitLog.args.transactionId;
+
+                await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+
+                const execRes = await multiSigWrapper.executeRemoveAuthorizedAddressAtIndexAsync(txId, notOwner);
+                const execLog = execRes.logs[1] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
                 expect(execLog.args.transactionId).to.be.bignumber.equal(txId);
 
                 const tx = await testAssetProxyOwner.transactions.callAsync(txId);
                 const isExecuted = tx[3];
                 expect(isExecuted).to.equal(true);
 
-                const isAuthorized = await erc20Proxy.authorized.callAsync(authorized);
-                expect(isAuthorized).to.equal(false);
+                const isAuthorizedAfter = await erc20Proxy.authorized.callAsync(authorized);
+                expect(isAuthorizedAfter).to.equal(false);
             });
 
             it('should throw if already executed', async () => {
@@ -449,7 +479,7 @@ describe('AssetProxyOwner', () => {
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
                 const execRes = await multiSigWrapper.executeRemoveAuthorizedAddressAtIndexAsync(txId, owners[0]);
-                const execLog = execRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
+                const execLog = execRes.logs[1] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
                 expect(execLog.args.transactionId).to.be.bignumber.equal(txId);
 
                 const tx = await testAssetProxyOwner.transactions.callAsync(txId);
diff --git a/packages/contracts/test/multisig/multi_sig_with_time_lock.ts b/packages/contracts/test/multisig/multi_sig_with_time_lock.ts
index 8eeeeca6b..0b17c298b 100644
--- a/packages/contracts/test/multisig/multi_sig_with_time_lock.ts
+++ b/packages/contracts/test/multisig/multi_sig_with_time_lock.ts
@@ -1,14 +1,21 @@
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { RevertReason } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
+import * as _ from 'lodash';
 
+import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
 import {
+    MultiSigWalletWithTimeLockConfirmationEventArgs,
+    MultiSigWalletWithTimeLockConfirmationTimeSetEventArgs,
     MultiSigWalletWithTimeLockContract,
+    MultiSigWalletWithTimeLockExecutionEventArgs,
+    MultiSigWalletWithTimeLockExecutionFailureEventArgs,
     MultiSigWalletWithTimeLockSubmissionEventArgs,
 } from '../../generated_contract_wrappers/multi_sig_wallet_with_time_lock';
 import { artifacts } from '../utils/artifacts';
-import { expectTransactionFailedWithoutReasonAsync } from '../utils/assertions';
+import { expectTransactionFailedAsync, expectTransactionFailedWithoutReasonAsync } from '../utils/assertions';
 import { increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
@@ -21,6 +28,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 // tslint:disable:no-unnecessary-type-assertion
 describe('MultiSigWalletWithTimeLock', () => {
     let owners: string[];
+    let notOwner: string;
     const REQUIRED_APPROVALS = new BigNumber(2);
     const SECONDS_TIME_LOCKED = new BigNumber(1000000);
 
@@ -32,7 +40,8 @@ describe('MultiSigWalletWithTimeLock', () => {
     });
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
-        owners = [accounts[0], accounts[1]];
+        owners = [accounts[0], accounts[1], accounts[2]];
+        notOwner = accounts[3];
     });
 
     let multiSig: MultiSigWalletWithTimeLockContract;
@@ -45,6 +54,171 @@ describe('MultiSigWalletWithTimeLock', () => {
         await blockchainLifecycle.revertAsync();
     });
 
+    describe('external_call', () => {
+        it('should be internal', async () => {
+            const secondsTimeLocked = new BigNumber(0);
+            multiSig = await MultiSigWalletWithTimeLockContract.deployFrom0xArtifactAsync(
+                artifacts.MultiSigWalletWithTimeLock,
+                provider,
+                txDefaults,
+                owners,
+                REQUIRED_APPROVALS,
+                secondsTimeLocked,
+            );
+            expect(_.isUndefined((multiSig as any).external_call)).to.be.equal(true);
+        });
+    });
+    describe('confirmTransaction', () => {
+        let txId: BigNumber;
+        beforeEach(async () => {
+            const secondsTimeLocked = new BigNumber(0);
+            multiSig = await MultiSigWalletWithTimeLockContract.deployFrom0xArtifactAsync(
+                artifacts.MultiSigWalletWithTimeLock,
+                provider,
+                txDefaults,
+                owners,
+                REQUIRED_APPROVALS,
+                secondsTimeLocked,
+            );
+            multiSigWrapper = new MultiSigWrapper(multiSig, provider);
+            const destination = notOwner;
+            const data = constants.NULL_BYTES;
+            const txReceipt = await multiSigWrapper.submitTransactionAsync(destination, data, owners[0]);
+            txId = (txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockSubmissionEventArgs>).args
+                .transactionId;
+        });
+        it('should revert if called by a non-owner', async () => {
+            await expectTransactionFailedWithoutReasonAsync(multiSigWrapper.confirmTransactionAsync(txId, notOwner));
+        });
+        it('should revert if transaction does not exist', async () => {
+            const nonexistentTxId = new BigNumber(123456789);
+            await expectTransactionFailedWithoutReasonAsync(
+                multiSigWrapper.confirmTransactionAsync(nonexistentTxId, owners[1]),
+            );
+        });
+        it('should revert if transaction is already confirmed by caller', async () => {
+            await expectTransactionFailedWithoutReasonAsync(multiSigWrapper.confirmTransactionAsync(txId, owners[0]));
+        });
+        it('should confirm transaction for caller and log a Confirmation event', async () => {
+            const txReceipt = await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockConfirmationEventArgs>;
+            expect(log.event).to.be.equal('Confirmation');
+            expect(log.args.sender).to.be.equal(owners[1]);
+            expect(log.args.transactionId).to.be.bignumber.equal(txId);
+        });
+        it('should revert if fully confirmed', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await expectTransactionFailedAsync(
+                multiSigWrapper.confirmTransactionAsync(txId, owners[2]),
+                RevertReason.TxFullyConfirmed,
+            );
+        });
+        it('should set the confirmation time of the transaction if it becomes fully confirmed', async () => {
+            const txReceipt = await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            const blockNum = await web3Wrapper.getBlockNumberAsync();
+            const timestamp = new BigNumber(await web3Wrapper.getBlockTimestampAsync(blockNum));
+            const log = txReceipt.logs[1] as LogWithDecodedArgs<MultiSigWalletWithTimeLockConfirmationTimeSetEventArgs>;
+            expect(log.args.confirmationTime).to.be.bignumber.equal(timestamp);
+            expect(log.args.transactionId).to.be.bignumber.equal(txId);
+        });
+    });
+    describe('executeTransaction', () => {
+        let txId: BigNumber;
+        const secondsTimeLocked = new BigNumber(1000000);
+        beforeEach(async () => {
+            multiSig = await MultiSigWalletWithTimeLockContract.deployFrom0xArtifactAsync(
+                artifacts.MultiSigWalletWithTimeLock,
+                provider,
+                txDefaults,
+                owners,
+                REQUIRED_APPROVALS,
+                secondsTimeLocked,
+            );
+            multiSigWrapper = new MultiSigWrapper(multiSig, provider);
+            const destination = notOwner;
+            const data = constants.NULL_BYTES;
+            const txReceipt = await multiSigWrapper.submitTransactionAsync(destination, data, owners[0]);
+            txId = (txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockSubmissionEventArgs>).args
+                .transactionId;
+        });
+        it('should revert if transaction has not been fully confirmed', async () => {
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            await expectTransactionFailedAsync(
+                multiSigWrapper.executeTransactionAsync(txId, owners[1]),
+                RevertReason.TxNotFullyConfirmed,
+            );
+        });
+        it('should revert if time lock has not passed', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await expectTransactionFailedAsync(
+                multiSigWrapper.executeTransactionAsync(txId, owners[1]),
+                RevertReason.TimeLockIncomplete,
+            );
+        });
+        it('should execute a transaction and log an Execution event if successful and called by owner', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            const txReceipt = await multiSigWrapper.executeTransactionAsync(txId, owners[1]);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockExecutionEventArgs>;
+            expect(log.event).to.be.equal('Execution');
+            expect(log.args.transactionId).to.be.bignumber.equal(txId);
+        });
+        it('should execute a transaction and log an Execution event if successful and called by non-owner', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            const txReceipt = await multiSigWrapper.executeTransactionAsync(txId, notOwner);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockExecutionEventArgs>;
+            expect(log.event).to.be.equal('Execution');
+            expect(log.args.transactionId).to.be.bignumber.equal(txId);
+        });
+        it('should revert if a required confirmation is revoked before executeTransaction is called', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            await multiSigWrapper.revokeConfirmationAsync(txId, owners[0]);
+            await expectTransactionFailedAsync(
+                multiSigWrapper.executeTransactionAsync(txId, owners[1]),
+                RevertReason.TxNotFullyConfirmed,
+            );
+        });
+        it('should revert if transaction has been executed', async () => {
+            await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            const txReceipt = await multiSigWrapper.executeTransactionAsync(txId, owners[1]);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockExecutionEventArgs>;
+            expect(log.args.transactionId).to.be.bignumber.equal(txId);
+            await expectTransactionFailedWithoutReasonAsync(multiSigWrapper.executeTransactionAsync(txId, owners[1]));
+        });
+        it("should log an ExecutionFailure event and not update the transaction's execution state if unsuccessful", async () => {
+            const contractWithoutFallback = await DummyERC20TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyERC20Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+                constants.DUMMY_TOKEN_DECIMALS,
+                constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+            );
+            const data = constants.NULL_BYTES;
+            const value = new BigNumber(10);
+            const submissionTxReceipt = await multiSigWrapper.submitTransactionAsync(
+                contractWithoutFallback.address,
+                data,
+                owners[0],
+                { value },
+            );
+            const newTxId = (submissionTxReceipt.logs[0] as LogWithDecodedArgs<
+                MultiSigWalletWithTimeLockSubmissionEventArgs
+            >).args.transactionId;
+            await multiSigWrapper.confirmTransactionAsync(newTxId, owners[1]);
+            await increaseTimeAndMineBlockAsync(secondsTimeLocked.toNumber());
+            const txReceipt = await multiSigWrapper.executeTransactionAsync(newTxId, owners[1]);
+            const executionFailureLog = txReceipt.logs[0] as LogWithDecodedArgs<
+                MultiSigWalletWithTimeLockExecutionFailureEventArgs
+            >;
+            expect(executionFailureLog.event).to.be.equal('ExecutionFailure');
+            expect(executionFailureLog.args.transactionId).to.be.bignumber.equal(newTxId);
+        });
+    });
     describe('changeTimeLock', () => {
         describe('initially non-time-locked', async () => {
             before(async () => {
@@ -78,8 +252,9 @@ describe('MultiSigWalletWithTimeLock', () => {
                 const res = await multiSigWrapper.submitTransactionAsync(destination, changeTimeLockData, owners[0]);
                 const log = res.logs[0] as LogWithDecodedArgs<MultiSigWalletWithTimeLockSubmissionEventArgs>;
                 const txId = log.args.transactionId;
-                return expectTransactionFailedWithoutReasonAsync(
+                return expectTransactionFailedAsync(
                     multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
+                    RevertReason.TxNotFullyConfirmed,
                 );
             });
 
@@ -94,7 +269,10 @@ describe('MultiSigWalletWithTimeLock', () => {
                 expect(confirmRes.logs).to.have.length(2);
 
                 const blockNum = await web3Wrapper.getBlockNumberAsync();
-                const blockInfo = await web3Wrapper.getBlockAsync(blockNum);
+                const blockInfo = await web3Wrapper.getBlockIfExistsAsync(blockNum);
+                if (_.isUndefined(blockInfo)) {
+                    throw new Error(`Unexpectedly failed to fetch block at #${blockNum}`);
+                }
                 const timestamp = new BigNumber(blockInfo.timestamp);
                 const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes.callAsync(txId));
 
@@ -147,8 +325,9 @@ describe('MultiSigWalletWithTimeLock', () => {
             });
 
             it('should throw if it has enough confirmations but is not past the time lock', async () => {
-                return expectTransactionFailedWithoutReasonAsync(
+                return expectTransactionFailedAsync(
                     multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
+                    RevertReason.TimeLockIncomplete,
                 );
             });
 
diff --git a/packages/contracts/test/tokens/erc721_token.ts b/packages/contracts/test/tokens/erc721_token.ts
new file mode 100644
index 000000000..e61fd7d51
--- /dev/null
+++ b/packages/contracts/test/tokens/erc721_token.ts
@@ -0,0 +1,279 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { RevertReason } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import {
+    DummyERC721ReceiverContract,
+    DummyERC721ReceiverTokenReceivedEventArgs,
+} from '../../generated_contract_wrappers/dummy_erc721_receiver';
+import {
+    DummyERC721TokenContract,
+    DummyERC721TokenTransferEventArgs,
+} from '../../generated_contract_wrappers/dummy_erc721_token';
+import { InvalidERC721ReceiverContract } from '../../generated_contract_wrappers/invalid_erc721_receiver';
+import { artifacts } from '../utils/artifacts';
+import { expectTransactionFailedAsync, expectTransactionFailedWithoutReasonAsync } from '../utils/assertions';
+import { chaiSetup } from '../utils/chai_setup';
+import { constants } from '../utils/constants';
+import { LogDecoder } from '../utils/log_decoder';
+import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+// tslint:disable:no-unnecessary-type-assertion
+describe('ERC721Token', () => {
+    let owner: string;
+    let spender: string;
+    let token: DummyERC721TokenContract;
+    let erc721Receiver: DummyERC721ReceiverContract;
+    let logDecoder: LogDecoder;
+    const tokenId = new BigNumber(1);
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = accounts[0];
+        spender = accounts[1];
+        token = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+            artifacts.DummyERC721Token,
+            provider,
+            txDefaults,
+            constants.DUMMY_TOKEN_NAME,
+            constants.DUMMY_TOKEN_SYMBOL,
+        );
+        erc721Receiver = await DummyERC721ReceiverContract.deployFrom0xArtifactAsync(
+            artifacts.DummyERC721Receiver,
+            provider,
+            txDefaults,
+        );
+        logDecoder = new LogDecoder(web3Wrapper);
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await token.mint.sendTransactionAsync(owner, tokenId, { from: owner }),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('transferFrom', () => {
+        it('should revert if the tokenId is not owner', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const unownedTokenId = new BigNumber(2);
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, unownedTokenId),
+                RevertReason.Erc721ZeroOwner,
+            );
+        });
+        it('should revert if transferring to a null address', async () => {
+            const from = owner;
+            const to = constants.NULL_ADDRESS;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721ZeroToAddress,
+            );
+        });
+        it('should revert if the from address does not own the token', async () => {
+            const from = spender;
+            const to = erc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721OwnerMismatch,
+            );
+        });
+        it('should revert if spender does not own the token, is not approved, and is not approved for all', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId, { from: spender }),
+                RevertReason.Erc721InvalidSpender,
+            );
+        });
+        it('should transfer the token if called by owner', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should transfer the token if spender is approved for all', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.setApprovalForAll.sendTransactionAsync(spender, isApproved),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should transfer the token if spender is individually approved', async () => {
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve.sendTransactionAsync(spender, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+
+            const approvedAddress = await token.getApproved.callAsync(tokenId);
+            expect(approvedAddress).to.be.equal(constants.NULL_ADDRESS);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+    });
+    describe('safeTransferFrom without data', () => {
+        it('should transfer token to a non-contract address if called by owner', async () => {
+            const from = owner;
+            const to = spender;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should revert if transferring to a contract address without onERC721Received', async () => {
+            const contract = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyERC721Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+            );
+            const from = owner;
+            const to = contract.address;
+            await expectTransactionFailedWithoutReasonAsync(
+                token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+        });
+        it('should revert if onERC721Received does not return the correct value', async () => {
+            const invalidErc721Receiver = await InvalidERC721ReceiverContract.deployFrom0xArtifactAsync(
+                artifacts.InvalidERC721Receiver,
+                provider,
+                txDefaults,
+            );
+            const from = owner;
+            const to = invalidErc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721InvalidSelector,
+            );
+        });
+        it('should transfer to contract and call onERC721Received with correct return value', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const transferLog = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC721ReceiverTokenReceivedEventArgs>;
+            expect(transferLog.args._from).to.be.equal(from);
+            expect(transferLog.args._to).to.be.equal(to);
+            expect(transferLog.args._tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.operator).to.be.equal(owner);
+            expect(receiverLog.args.from).to.be.equal(from);
+            expect(receiverLog.args.tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.data).to.be.equal(constants.NULL_BYTES);
+        });
+    });
+    describe('safeTransferFrom with data', () => {
+        const data = '0x0102030405060708090a0b0c0d0e0f';
+        it('should transfer token to a non-contract address if called by owner', async () => {
+            const from = owner;
+            const to = spender;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should revert if transferring to a contract address without onERC721Received', async () => {
+            const contract = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyERC721Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+            );
+            const from = owner;
+            const to = contract.address;
+            await expectTransactionFailedWithoutReasonAsync(
+                token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+        });
+        it('should revert if onERC721Received does not return the correct value', async () => {
+            const invalidErc721Receiver = await InvalidERC721ReceiverContract.deployFrom0xArtifactAsync(
+                artifacts.InvalidERC721Receiver,
+                provider,
+                txDefaults,
+            );
+            const from = owner;
+            const to = invalidErc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+                RevertReason.Erc721InvalidSelector,
+            );
+        });
+        it('should transfer to contract and call onERC721Received with correct return value', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const transferLog = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC721ReceiverTokenReceivedEventArgs>;
+            expect(transferLog.args._from).to.be.equal(from);
+            expect(transferLog.args._to).to.be.equal(to);
+            expect(transferLog.args._tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.operator).to.be.equal(owner);
+            expect(receiverLog.args.from).to.be.equal(from);
+            expect(receiverLog.args.tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.data).to.be.equal(data);
+        });
+    });
+});
+// tslint:enable:no-unnecessary-type-assertion
diff --git a/packages/contracts/test/tokens/unlimited_allowance_token.ts b/packages/contracts/test/tokens/unlimited_allowance_token.ts
index 81d931fc5..63680fe9b 100644
--- a/packages/contracts/test/tokens/unlimited_allowance_token.ts
+++ b/packages/contracts/test/tokens/unlimited_allowance_token.ts
@@ -5,7 +5,7 @@ import * as chai from 'chai';
 
 import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
 import { artifacts } from '../utils/artifacts';
-import { expectContractCallFailed } from '../utils/assertions';
+import { expectContractCallFailedAsync } from '../utils/assertions';
 import { chaiSetup } from '../utils/chai_setup';
 import { constants } from '../utils/constants';
 import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
@@ -17,7 +17,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 describe('UnlimitedAllowanceToken', () => {
     let owner: string;
     let spender: string;
-    const MAX_MINT_VALUE = new BigNumber(100000000000000000000);
+    const MAX_MINT_VALUE = new BigNumber(10000000000000000000000);
     let token: DummyERC20TokenContract;
 
     before(async () => {
@@ -54,7 +54,7 @@ describe('UnlimitedAllowanceToken', () => {
         it('should throw if owner has insufficient balance', async () => {
             const ownerBalance = await token.balanceOf.callAsync(owner);
             const amountToTransfer = ownerBalance.plus(1);
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 token.transfer.callAsync(spender, amountToTransfer, { from: owner }),
                 RevertReason.Erc20InsufficientBalance,
             );
@@ -93,7 +93,7 @@ describe('UnlimitedAllowanceToken', () => {
                 await token.approve.sendTransactionAsync(spender, amountToTransfer, { from: owner }),
                 constants.AWAIT_TRANSACTION_MINED_MS,
             );
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 token.transferFrom.callAsync(owner, spender, amountToTransfer, {
                     from: spender,
                 }),
@@ -109,7 +109,7 @@ describe('UnlimitedAllowanceToken', () => {
             const isSpenderAllowanceInsufficient = spenderAllowance.cmp(amountToTransfer) < 0;
             expect(isSpenderAllowanceInsufficient).to.be.true();
 
-            return expectContractCallFailed(
+            return expectContractCallFailedAsync(
                 token.transferFrom.callAsync(owner, spender, amountToTransfer, {
                     from: spender,
                 }),
diff --git a/packages/contracts/test/utils/address_utils.ts b/packages/contracts/test/utils/address_utils.ts
index a9fb6921a..3cf8ec786 100644
--- a/packages/contracts/test/utils/address_utils.ts
+++ b/packages/contracts/test/utils/address_utils.ts
@@ -1,4 +1,5 @@
-import { crypto, generatePseudoRandomSalt } from '@0xproject/order-utils';
+import { generatePseudoRandomSalt } from '@0xproject/order-utils';
+import { crypto } from '@0xproject/order-utils/lib/src/crypto';
 
 export const addressUtils = {
     generatePseudoRandomAddress(): string {
diff --git a/packages/contracts/test/utils/artifacts.ts b/packages/contracts/test/utils/artifacts.ts
index e608ee174..53f2a4e4e 100644
--- a/packages/contracts/test/utils/artifacts.ts
+++ b/packages/contracts/test/utils/artifacts.ts
@@ -1,18 +1,23 @@
-import { ContractArtifact } from '@0xproject/sol-compiler';
+import { ContractArtifact } from 'ethereum-types';
 
 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 DummyMultipleReturnERC20Token from '../../artifacts/DummyMultipleReturnERC20Token.json';
+import * as DummyNoReturnERC20Token from '../../artifacts/DummyNoReturnERC20Token.json';
 import * as ERC20Proxy from '../../artifacts/ERC20Proxy.json';
 import * as ERC721Proxy from '../../artifacts/ERC721Proxy.json';
 import * as Exchange from '../../artifacts/Exchange.json';
 import * as ExchangeWrapper from '../../artifacts/ExchangeWrapper.json';
 import * as Forwarder from '../../artifacts/Forwarder.json';
 import * as IAssetProxy from '../../artifacts/IAssetProxy.json';
+import * as InvalidERC721Receiver from '../../artifacts/InvalidERC721Receiver.json';
 import * as MixinAuthorizable from '../../artifacts/MixinAuthorizable.json';
 import * as MultiSigWallet from '../../artifacts/MultiSigWallet.json';
 import * as MultiSigWalletWithTimeLock from '../../artifacts/MultiSigWalletWithTimeLock.json';
+import * as OrderValidator from '../../artifacts/OrderValidator.json';
+import * as ReentrantERC20Token from '../../artifacts/ReentrantERC20Token.json';
 import * as TestAssetProxyDispatcher from '../../artifacts/TestAssetProxyDispatcher.json';
 import * as TestAssetProxyOwner from '../../artifacts/TestAssetProxyOwner.json';
 import * as TestConstants from '../../artifacts/TestConstants.json';
@@ -20,6 +25,7 @@ import * as TestExchangeInternals from '../../artifacts/TestExchangeInternals.js
 import * as TestLibBytes from '../../artifacts/TestLibBytes.json';
 import * as TestLibs from '../../artifacts/TestLibs.json';
 import * as TestSignatureValidator from '../../artifacts/TestSignatureValidator.json';
+import * as TestStaticCallReceiver from '../../artifacts/TestStaticCallReceiver.json';
 import * as TokenRegistry from '../../artifacts/TokenRegistry.json';
 import * as Validator from '../../artifacts/Validator.json';
 import * as Wallet from '../../artifacts/Wallet.json';
@@ -32,6 +38,8 @@ export const artifacts = {
     DummyERC20Token: (DummyERC20Token as any) as ContractArtifact,
     DummyERC721Receiver: (DummyERC721Receiver as any) as ContractArtifact,
     DummyERC721Token: (DummyERC721Token as any) as ContractArtifact,
+    DummyMultipleReturnERC20Token: (DummyMultipleReturnERC20Token as any) as ContractArtifact,
+    DummyNoReturnERC20Token: (DummyNoReturnERC20Token as any) as ContractArtifact,
     ERC20Proxy: (ERC20Proxy as any) as ContractArtifact,
     ERC721Proxy: (ERC721Proxy as any) as ContractArtifact,
     Exchange: (Exchange as any) as ContractArtifact,
@@ -39,9 +47,12 @@ export const artifacts = {
     EtherToken: (EtherToken as any) as ContractArtifact,
     Forwarder: (Forwarder as any) as ContractArtifact,
     IAssetProxy: (IAssetProxy as any) as ContractArtifact,
+    InvalidERC721Receiver: (InvalidERC721Receiver as any) as ContractArtifact,
     MixinAuthorizable: (MixinAuthorizable as any) as ContractArtifact,
     MultiSigWallet: (MultiSigWallet as any) as ContractArtifact,
     MultiSigWalletWithTimeLock: (MultiSigWalletWithTimeLock as any) as ContractArtifact,
+    OrderValidator: (OrderValidator as any) as ContractArtifact,
+    ReentrantERC20Token: (ReentrantERC20Token as any) as ContractArtifact,
     TestAssetProxyOwner: (TestAssetProxyOwner as any) as ContractArtifact,
     TestAssetProxyDispatcher: (TestAssetProxyDispatcher as any) as ContractArtifact,
     TestConstants: (TestConstants as any) as ContractArtifact,
@@ -49,6 +60,7 @@ export const artifacts = {
     TestLibs: (TestLibs as any) as ContractArtifact,
     TestExchangeInternals: (TestExchangeInternals as any) as ContractArtifact,
     TestSignatureValidator: (TestSignatureValidator as any) as ContractArtifact,
+    TestStaticCallReceiver: (TestStaticCallReceiver as any) as ContractArtifact,
     Validator: (Validator as any) as ContractArtifact,
     Wallet: (Wallet as any) as ContractArtifact,
     TokenRegistry: (TokenRegistry as any) as ContractArtifact,
diff --git a/packages/contracts/test/utils/assertions.ts b/packages/contracts/test/utils/assertions.ts
index 61df800c8..3361a751a 100644
--- a/packages/contracts/test/utils/assertions.ts
+++ b/packages/contracts/test/utils/assertions.ts
@@ -159,7 +159,7 @@ export async function expectTransactionFailedWithoutReasonAsync(p: sendTransacti
  * @returns a new Promise which will reject if the conditions are not met and
  * otherwise resolve with no value.
  */
-export async function expectContractCallFailed<T>(p: Promise<T>, reason: RevertReason): Promise<void> {
+export async function expectContractCallFailedAsync<T>(p: Promise<T>, reason: RevertReason): Promise<void> {
     return expect(p).to.be.rejectedWith(reason);
 }
 
@@ -180,7 +180,20 @@ export async function expectContractCallFailedWithoutReasonAsync<T>(p: Promise<T
  * @returns a new Promise which will reject if the conditions are not met and
  * otherwise resolve with no value.
  */
-export async function expectContractCreationFailedWithoutReason<T>(p: Promise<T>): Promise<void> {
+export async function expectContractCreationFailedAsync<T>(
+    p: sendTransactionResult,
+    reason: RevertReason,
+): Promise<void> {
+    return expectTransactionFailedAsync(p, reason);
+}
+
+/**
+ * Resolves if the contract creation/deployment fails without a revert reason.
+ * @param p a Promise resulting from a contract creation/deployment
+ * @returns a new Promise which will reject if the conditions are not met and
+ * otherwise resolve with no value.
+ */
+export async function expectContractCreationFailedWithoutReasonAsync<T>(p: Promise<T>): Promise<void> {
     const errMessage = await _getTransactionFailedErrorMessageAsync();
     return expect(p).to.be.rejectedWith(errMessage);
 }
diff --git a/packages/contracts/test/utils/block_timestamp.ts b/packages/contracts/test/utils/block_timestamp.ts
index 1159792c4..66c13eed1 100644
--- a/packages/contracts/test/utils/block_timestamp.ts
+++ b/packages/contracts/test/utils/block_timestamp.ts
@@ -35,6 +35,9 @@ export async function increaseTimeAndMineBlockAsync(seconds: number): Promise<nu
  * @returns a new Promise which will resolve with the timestamp in seconds.
  */
 export async function getLatestBlockTimestampAsync(): Promise<number> {
-    const currentBlock = await web3Wrapper.getBlockAsync('latest');
-    return currentBlock.timestamp;
+    const currentBlockIfExists = await web3Wrapper.getBlockIfExistsAsync('latest');
+    if (_.isUndefined(currentBlockIfExists)) {
+        throw new Error(`Unable to fetch latest block.`);
+    }
+    return currentBlockIfExists.timestamp;
 }
diff --git a/packages/contracts/test/utils/constants.ts b/packages/contracts/test/utils/constants.ts
index 65eaee398..b9ba8ccb9 100644
--- a/packages/contracts/test/utils/constants.ts
+++ b/packages/contracts/test/utils/constants.ts
@@ -51,4 +51,17 @@ export const constants = {
     WORD_LENGTH: 32,
     ZERO_AMOUNT: new BigNumber(0),
     PERCENTAGE_DENOMINATOR: new BigNumber(10).pow(18),
+    FUNCTIONS_WITH_MUTEX: [
+        'FILL_ORDER',
+        'FILL_OR_KILL_ORDER',
+        'BATCH_FILL_ORDERS',
+        'BATCH_FILL_OR_KILL_ORDERS',
+        'MARKET_BUY_ORDERS',
+        'MARKET_SELL_ORDERS',
+        'MATCH_ORDERS',
+        'CANCEL_ORDER',
+        'BATCH_CANCEL_ORDERS',
+        'CANCEL_ORDERS_UP_TO',
+        'SET_SIGNATURE_VALIDATOR_APPROVAL',
+    ],
 };
diff --git a/packages/contracts/test/utils/erc20_wrapper.ts b/packages/contracts/test/utils/erc20_wrapper.ts
index 424aae579..526ffe9f8 100644
--- a/packages/contracts/test/utils/erc20_wrapper.ts
+++ b/packages/contracts/test/utils/erc20_wrapper.ts
@@ -20,6 +20,13 @@ export class ERC20Wrapper {
     private readonly _dummyTokenContracts: DummyERC20TokenContract[];
     private _proxyContract?: ERC20ProxyContract;
     private _proxyIdIfExists?: string;
+    /**
+     * Instanitates an ERC20Wrapper
+     * @param provider Web3 provider to use for all JSON RPC requests
+     * @param tokenOwnerAddresses Addresses that we want to endow as owners for dummy ERC20 tokens
+     * @param contractOwnerAddress Desired owner of the contract
+     * Instance of ERC20Wrapper
+     */
     constructor(provider: Provider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
         this._dummyTokenContracts = [];
         this._web3Wrapper = new Web3Wrapper(provider);
diff --git a/packages/contracts/test/utils/erc721_wrapper.ts b/packages/contracts/test/utils/erc721_wrapper.ts
index d023b4d02..743d10706 100644
--- a/packages/contracts/test/utils/erc721_wrapper.ts
+++ b/packages/contracts/test/utils/erc721_wrapper.ts
@@ -81,7 +81,8 @@ export class ERC721Wrapper {
     }
     public async doesTokenExistAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const doesExist = await tokenContract.exists.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const doesExist = owner !== constants.NULL_ADDRESS;
         return doesExist;
     }
     public async approveProxyAsync(tokenAddress: string, tokenId: BigNumber): Promise<void> {
diff --git a/packages/contracts/test/utils/exchange_wrapper.ts b/packages/contracts/test/utils/exchange_wrapper.ts
index d57592d6d..619d43994 100644
--- a/packages/contracts/test/utils/exchange_wrapper.ts
+++ b/packages/contracts/test/utils/exchange_wrapper.ts
@@ -17,7 +17,7 @@ export class ExchangeWrapper {
     constructor(exchangeContract: ExchangeContract, provider: Provider) {
         this._exchange = exchangeContract;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._exchange.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async fillOrderAsync(
         signedOrder: SignedOrder,
@@ -266,4 +266,7 @@ export class ExchangeWrapper {
         );
         return data;
     }
+    public getExchangeAddress(): string {
+        return this._exchange.address;
+    }
 }
diff --git a/packages/contracts/test/utils/fill_order_combinatorial_utils.ts b/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
index 284c4a2db..92d0f4003 100644
--- a/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
+++ b/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
@@ -81,6 +81,12 @@ export async function fillOrderCombinatorialUtilsFactoryAsync(
         erc20FiveDecimalTokenCount,
         fiveDecimals,
     );
+    const zeroDecimals = new BigNumber(0);
+    const erc20ZeroDecimalTokenCount = 2;
+    const [erc20ZeroDecimalTokenA, erc20ZeroDecimalTokenB] = await erc20Wrapper.deployDummyTokensAsync(
+        erc20ZeroDecimalTokenCount,
+        zeroDecimals,
+    );
     const erc20Proxy = await erc20Wrapper.deployProxyAsync();
     await erc20Wrapper.setBalancesAndAllowancesAsync();
 
@@ -119,6 +125,7 @@ export async function fillOrderCombinatorialUtilsFactoryAsync(
         zrxToken.address,
         [erc20EighteenDecimalTokenA.address, erc20EighteenDecimalTokenB.address],
         [erc20FiveDecimalTokenA.address, erc20FiveDecimalTokenB.address],
+        [erc20ZeroDecimalTokenA.address, erc20ZeroDecimalTokenB.address],
         erc721Token,
         erc721Balances,
         exchangeContract.address,
@@ -460,17 +467,17 @@ export class FillOrderCombinatorialUtils {
             ? remainingTakerAmountToFill
             : alreadyFilledTakerAmount.add(takerAssetFillAmount);
 
-        const expFilledMakerAmount = orderUtils.getPartialAmount(
+        const expFilledMakerAmount = orderUtils.getPartialAmountFloor(
             expFilledTakerAmount,
             signedOrder.takerAssetAmount,
             signedOrder.makerAssetAmount,
         );
-        const expMakerFeePaid = orderUtils.getPartialAmount(
+        const expMakerFeePaid = orderUtils.getPartialAmountFloor(
             expFilledTakerAmount,
             signedOrder.takerAssetAmount,
             signedOrder.makerFee,
         );
-        const expTakerFeePaid = orderUtils.getPartialAmount(
+        const expTakerFeePaid = orderUtils.getPartialAmountFloor(
             expFilledTakerAmount,
             signedOrder.takerAssetAmount,
             signedOrder.takerFee,
@@ -497,7 +504,11 @@ export class FillOrderCombinatorialUtils {
         const actFilledTakerAmount = await this.exchangeWrapper.getTakerAssetFilledAmountAsync(orderHash);
         expect(actFilledTakerAmount).to.be.bignumber.equal(expFilledTakerAmount, 'filledTakerAmount');
 
-        expect(txReceipt.logs.length).to.be.equal(1, 'logs length');
+        const exchangeLogs = _.filter(
+            txReceipt.logs,
+            txLog => txLog.address === this.exchangeWrapper.getExchangeAddress(),
+        );
+        expect(exchangeLogs.length).to.be.equal(1, 'logs length');
         // tslint:disable-next-line:no-unnecessary-type-assertion
         const log = txReceipt.logs[0] as LogWithDecodedArgs<ExchangeFillEventArgs>;
         expect(log.args.makerAddress).to.be.equal(makerAddress, 'log.args.makerAddress');
@@ -657,7 +668,7 @@ export class FillOrderCombinatorialUtils {
         signedOrder: SignedOrder,
         takerAssetFillAmount: BigNumber,
     ): Promise<void> {
-        const makerAssetFillAmount = orderUtils.getPartialAmount(
+        const makerAssetFillAmount = orderUtils.getPartialAmountFloor(
             takerAssetFillAmount,
             signedOrder.takerAssetAmount,
             signedOrder.makerAssetAmount,
@@ -694,7 +705,7 @@ export class FillOrderCombinatorialUtils {
                 );
         }
 
-        const makerFee = orderUtils.getPartialAmount(
+        const makerFee = orderUtils.getPartialAmountFloor(
             takerAssetFillAmount,
             signedOrder.takerAssetAmount,
             signedOrder.makerFee,
@@ -818,7 +829,7 @@ export class FillOrderCombinatorialUtils {
                 );
         }
 
-        const takerFee = orderUtils.getPartialAmount(
+        const takerFee = orderUtils.getPartialAmountFloor(
             takerAssetFillAmount,
             signedOrder.takerAssetAmount,
             signedOrder.takerFee,
diff --git a/packages/contracts/test/utils/forwarder_wrapper.ts b/packages/contracts/test/utils/forwarder_wrapper.ts
index 5b9a63ddf..de247a878 100644
--- a/packages/contracts/test/utils/forwarder_wrapper.ts
+++ b/packages/contracts/test/utils/forwarder_wrapper.ts
@@ -58,7 +58,7 @@ export class ForwarderWrapper {
     constructor(contractInstance: ForwarderContract, provider: Provider) {
         this._forwarderContract = contractInstance;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._forwarderContract.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async marketSellOrdersWithEthAsync(
         orders: SignedOrder[],
diff --git a/packages/contracts/test/utils/log_decoder.ts b/packages/contracts/test/utils/log_decoder.ts
index 5a4801319..144a18dd1 100644
--- a/packages/contracts/test/utils/log_decoder.ts
+++ b/packages/contracts/test/utils/log_decoder.ts
@@ -1,8 +1,8 @@
-import { ContractArtifact } from '@0xproject/sol-compiler';
 import { AbiDecoder, BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import {
     AbiDefinition,
+    ContractArtifact,
     DecodedLogArgs,
     LogEntry,
     LogWithDecodedArgs,
@@ -16,7 +16,6 @@ import { constants } from './constants';
 
 export class LogDecoder {
     private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _contractAddress: string;
     private readonly _abiDecoder: AbiDecoder;
     public static wrapLogBigNumbers(log: any): any {
         const argNames = _.keys(log.args);
@@ -27,9 +26,8 @@ export class LogDecoder {
             }
         }
     }
-    constructor(web3Wrapper: Web3Wrapper, contractAddress: string) {
+    constructor(web3Wrapper: Web3Wrapper) {
         this._web3Wrapper = web3Wrapper;
-        this._contractAddress = contractAddress;
         const abiArrays: AbiDefinition[][] = [];
         _.forEach(artifacts, (artifact: ContractArtifact) => {
             const compilerOutput = artifact.compilerOutput;
@@ -48,7 +46,6 @@ export class LogDecoder {
     }
     public async getTxWithDecodedLogsAsync(txHash: string): Promise<TransactionReceiptWithDecodedLogs> {
         const tx = await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
-        tx.logs = _.filter(tx.logs, log => log.address === this._contractAddress);
         tx.logs = _.map(tx.logs, log => this.decodeLogOrThrow(log));
         return tx;
     }
diff --git a/packages/contracts/test/utils/match_order_tester.ts b/packages/contracts/test/utils/match_order_tester.ts
index fa2eabc12..e0c55b834 100644
--- a/packages/contracts/test/utils/match_order_tester.ts
+++ b/packages/contracts/test/utils/match_order_tester.ts
@@ -4,11 +4,20 @@ import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
 import * as _ from 'lodash';
 
+import { TransactionReceiptWithDecodedLogs } from '../../../../node_modules/ethereum-types';
+
 import { chaiSetup } from './chai_setup';
 import { ERC20Wrapper } from './erc20_wrapper';
 import { ERC721Wrapper } from './erc721_wrapper';
 import { ExchangeWrapper } from './exchange_wrapper';
-import { ERC20BalancesByOwner, ERC721TokenIdsByOwner, TransferAmountsByMatchOrders as TransferAmounts } from './types';
+import {
+    ERC20BalancesByOwner,
+    ERC721TokenIdsByOwner,
+    OrderInfo,
+    OrderStatus,
+    TransferAmountsByMatchOrders as TransferAmounts,
+    TransferAmountsLoggedByMatchOrders as LoggedTransferAmounts,
+} from './types';
 
 chaiSetup.configure();
 const expect = chai.expect;
@@ -18,43 +27,107 @@ export class MatchOrderTester {
     private readonly _erc20Wrapper: ERC20Wrapper;
     private readonly _erc721Wrapper: ERC721Wrapper;
     private readonly _feeTokenAddress: string;
-
-    /// @dev Compares a pair of ERC20 balances and a pair of ERC721 token owners.
-    /// @param expectedNewERC20BalancesByOwner Expected ERC20 balances.
-    /// @param realERC20BalancesByOwner Actual ERC20 balances.
-    /// @param expectedNewERC721TokenIdsByOwner Expected ERC721 token owners.
-    /// @param realERC721TokenIdsByOwner Actual ERC20 token owners.
-    /// @return True only if ERC20 balances match and ERC721 token owners match.
-    private static _compareExpectedAndRealBalances(
-        expectedNewERC20BalancesByOwner: ERC20BalancesByOwner,
+    /// @dev Checks values from the logs produced by Exchange.matchOrders against the expected transfer amounts.
+    ///      Values include the amounts transferred from the left/right makers and taker, along with
+    ///      the fees paid on each matched order. These are also the return values of MatchOrders.
+    /// @param signedOrderLeft First matched order.
+    /// @param signedOrderRight Second matched order.
+    /// @param transactionReceipt Transaction receipt and logs produced by Exchange.matchOrders.
+    /// @param takerAddress Address of taker (account that called Exchange.matchOrders)
+    /// @param expectedTransferAmounts Expected amounts transferred as a result of order matching.
+    private static async _assertLogsAsync(
+        signedOrderLeft: SignedOrder,
+        signedOrderRight: SignedOrder,
+        transactionReceipt: TransactionReceiptWithDecodedLogs,
+        takerAddress: string,
+        expectedTransferAmounts: TransferAmounts,
+    ): Promise<void> {
+        // Should have two fill event logs -- one for each order.
+        const transactionFillLogs = _.filter(transactionReceipt.logs, ['event', 'Fill']);
+        expect(transactionFillLogs.length, 'Checking number of logs').to.be.equal(2);
+        // First log is for left fill
+        const leftLog = (transactionFillLogs[0] as any).args as LoggedTransferAmounts;
+        expect(leftLog.makerAddress, 'Checking logged maker address of left order').to.be.equal(
+            signedOrderLeft.makerAddress,
+        );
+        expect(leftLog.takerAddress, 'Checking logged taker address of right order').to.be.equal(takerAddress);
+        const amountBoughtByLeftMaker = new BigNumber(leftLog.takerAssetFilledAmount);
+        const amountSoldByLeftMaker = new BigNumber(leftLog.makerAssetFilledAmount);
+        const feePaidByLeftMaker = new BigNumber(leftLog.makerFeePaid);
+        const feePaidByTakerLeft = new BigNumber(leftLog.takerFeePaid);
+        // Second log is for right fill
+        const rightLog = (transactionFillLogs[1] as any).args as LoggedTransferAmounts;
+        expect(rightLog.makerAddress, 'Checking logged maker address of right order').to.be.equal(
+            signedOrderRight.makerAddress,
+        );
+        expect(rightLog.takerAddress, 'Checking loggerd taker address of right order').to.be.equal(takerAddress);
+        const amountBoughtByRightMaker = new BigNumber(rightLog.takerAssetFilledAmount);
+        const amountSoldByRightMaker = new BigNumber(rightLog.makerAssetFilledAmount);
+        const feePaidByRightMaker = new BigNumber(rightLog.makerFeePaid);
+        const feePaidByTakerRight = new BigNumber(rightLog.takerFeePaid);
+        // Derive amount received by taker
+        const amountReceivedByTaker = amountSoldByLeftMaker.sub(amountBoughtByRightMaker);
+        // Assert log values - left order
+        expect(amountBoughtByLeftMaker, 'Checking logged amount bought by left maker').to.be.bignumber.equal(
+            expectedTransferAmounts.amountBoughtByLeftMaker,
+        );
+        expect(amountSoldByLeftMaker, 'Checking logged amount sold by left maker').to.be.bignumber.equal(
+            expectedTransferAmounts.amountSoldByLeftMaker,
+        );
+        expect(feePaidByLeftMaker, 'Checking logged fee paid by left maker').to.be.bignumber.equal(
+            expectedTransferAmounts.feePaidByLeftMaker,
+        );
+        expect(feePaidByTakerLeft, 'Checking logged fee paid on left order by taker').to.be.bignumber.equal(
+            expectedTransferAmounts.feePaidByTakerLeft,
+        );
+        // Assert log values - right order
+        expect(amountBoughtByRightMaker, 'Checking logged amount bought by right maker').to.be.bignumber.equal(
+            expectedTransferAmounts.amountBoughtByRightMaker,
+        );
+        expect(amountSoldByRightMaker, 'Checking logged amount sold by right maker').to.be.bignumber.equal(
+            expectedTransferAmounts.amountSoldByRightMaker,
+        );
+        expect(feePaidByRightMaker, 'Checking logged fee paid by right maker').to.be.bignumber.equal(
+            expectedTransferAmounts.feePaidByRightMaker,
+        );
+        expect(feePaidByTakerRight, 'Checking logged fee paid on right order by taker').to.be.bignumber.equal(
+            expectedTransferAmounts.feePaidByTakerRight,
+        );
+        // Assert derived amount received by taker
+        expect(amountReceivedByTaker, 'Checking logged amount received by taker').to.be.bignumber.equal(
+            expectedTransferAmounts.amountReceivedByTaker,
+        );
+    }
+    /// @dev Asserts all expected ERC20 and ERC721 account holdings match the real holdings.
+    /// @param expectedERC20BalancesByOwner Expected ERC20 balances.
+    /// @param realERC20BalancesByOwner Real ERC20 balances.
+    /// @param expectedERC721TokenIdsByOwner Expected ERC721 token owners.
+    /// @param realERC721TokenIdsByOwner Real ERC20 token owners.
+    private static async _assertAllKnownBalancesAsync(
+        expectedERC20BalancesByOwner: ERC20BalancesByOwner,
         realERC20BalancesByOwner: ERC20BalancesByOwner,
-        expectedNewERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
+        expectedERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
         realERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
-    ): boolean {
+    ): Promise<void> {
         // ERC20 Balances
-        const doesErc20BalancesMatch = _.isEqual(expectedNewERC20BalancesByOwner, realERC20BalancesByOwner);
-        if (!doesErc20BalancesMatch) {
-            return false;
-        }
+        const areERC20BalancesEqual = _.isEqual(expectedERC20BalancesByOwner, realERC20BalancesByOwner);
+        expect(areERC20BalancesEqual, 'Checking all known ERC20 account balances').to.be.true();
         // ERC721 Token Ids
-        const sortedExpectedNewERC721TokenIdsByOwner = _.mapValues(
-            expectedNewERC721TokenIdsByOwner,
-            tokenIdsByOwner => {
-                _.mapValues(tokenIdsByOwner, tokenIds => {
-                    _.sortBy(tokenIds);
-                });
-            },
-        );
+        const sortedExpectedNewERC721TokenIdsByOwner = _.mapValues(expectedERC721TokenIdsByOwner, tokenIdsByOwner => {
+            _.mapValues(tokenIdsByOwner, tokenIds => {
+                _.sortBy(tokenIds);
+            });
+        });
         const sortedNewERC721TokenIdsByOwner = _.mapValues(realERC721TokenIdsByOwner, tokenIdsByOwner => {
             _.mapValues(tokenIdsByOwner, tokenIds => {
                 _.sortBy(tokenIds);
             });
         });
-        const doesErc721TokenIdsMatch = _.isEqual(
+        const areERC721TokenIdsEqual = _.isEqual(
             sortedExpectedNewERC721TokenIdsByOwner,
             sortedNewERC721TokenIdsByOwner,
         );
-        return doesErc721TokenIdsMatch;
+        expect(areERC721TokenIdsEqual, 'Checking all known ERC721 account balances').to.be.true();
     }
     /// @dev Constructs new MatchOrderTester.
     /// @param exchangeWrapper Used to call to the Exchange.
@@ -72,150 +145,199 @@ export class MatchOrderTester {
         this._erc721Wrapper = erc721Wrapper;
         this._feeTokenAddress = feeTokenAddress;
     }
-    /// @dev Matches two complementary orders and validates results.
-    ///      Validation either succeeds or throws.
+    /// @dev Matches two complementary orders and asserts results.
     /// @param signedOrderLeft First matched order.
     /// @param signedOrderRight Second matched order.
     /// @param takerAddress Address of taker (the address who matched the two orders)
     /// @param erc20BalancesByOwner Current ERC20 balances.
     /// @param erc721TokenIdsByOwner Current ERC721 token owners.
-    /// @param initialTakerAssetFilledAmountLeft Current amount the left order has been filled.
-    /// @param initialTakerAssetFilledAmountRight Current amount the right order has been filled.
+    /// @param expectedTransferAmounts Expected amounts transferred as a result of order matching.
+    /// @param initialLeftOrderFilledAmount How much left order has been filled, prior to matching orders.
+    /// @param initialRightOrderFilledAmount How much the right order has been filled, prior to matching orders.
     /// @return New ERC20 balances & ERC721 token owners.
-    public async matchOrdersAndVerifyBalancesAsync(
+    public async matchOrdersAndAssertEffectsAsync(
         signedOrderLeft: SignedOrder,
         signedOrderRight: SignedOrder,
         takerAddress: string,
         erc20BalancesByOwner: ERC20BalancesByOwner,
         erc721TokenIdsByOwner: ERC721TokenIdsByOwner,
-        initialTakerAssetFilledAmountLeft?: BigNumber,
-        initialTakerAssetFilledAmountRight?: BigNumber,
+        expectedTransferAmounts: TransferAmounts,
+        initialLeftOrderFilledAmount: BigNumber = new BigNumber(0),
+        initialRightOrderFilledAmount: BigNumber = new BigNumber(0),
     ): Promise<[ERC20BalancesByOwner, ERC721TokenIdsByOwner]> {
-        // Verify Left order preconditions
-        const orderTakerAssetFilledAmountLeft = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
-            orderHashUtils.getOrderHashHex(signedOrderLeft),
-        );
-        const expectedOrderFilledAmountLeft = initialTakerAssetFilledAmountLeft
-            ? initialTakerAssetFilledAmountLeft
-            : new BigNumber(0);
-        expect(expectedOrderFilledAmountLeft).to.be.bignumber.equal(orderTakerAssetFilledAmountLeft);
-        // Verify Right order preconditions
-        const orderTakerAssetFilledAmountRight = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
-            orderHashUtils.getOrderHashHex(signedOrderRight),
+        // Assert initial order states
+        await this._assertInitialOrderStatesAsync(
+            signedOrderLeft,
+            signedOrderRight,
+            initialLeftOrderFilledAmount,
+            initialRightOrderFilledAmount,
         );
-        const expectedOrderFilledAmountRight = initialTakerAssetFilledAmountRight
-            ? initialTakerAssetFilledAmountRight
-            : new BigNumber(0);
-        expect(expectedOrderFilledAmountRight).to.be.bignumber.equal(orderTakerAssetFilledAmountRight);
         // Match left & right orders
-        await this._exchangeWrapper.matchOrdersAsync(signedOrderLeft, signedOrderRight, takerAddress);
+        const transactionReceipt = await this._exchangeWrapper.matchOrdersAsync(
+            signedOrderLeft,
+            signedOrderRight,
+            takerAddress,
+        );
         const newERC20BalancesByOwner = await this._erc20Wrapper.getBalancesAsync();
         const newERC721TokenIdsByOwner = await this._erc721Wrapper.getBalancesAsync();
-        // Calculate expected balance changes
-        const expectedTransferAmounts = await this._calculateExpectedTransferAmountsAsync(
+        // Assert logs
+        await MatchOrderTester._assertLogsAsync(
             signedOrderLeft,
             signedOrderRight,
-            orderTakerAssetFilledAmountLeft,
-            orderTakerAssetFilledAmountRight,
+            transactionReceipt,
+            takerAddress,
+            expectedTransferAmounts,
         );
-        let expectedERC20BalancesByOwner: ERC20BalancesByOwner;
-        let expectedERC721TokenIdsByOwner: ERC721TokenIdsByOwner;
-        [expectedERC20BalancesByOwner, expectedERC721TokenIdsByOwner] = this._calculateExpectedBalances(
+        // Assert exchange state
+        await this._assertExchangeStateAsync(
             signedOrderLeft,
             signedOrderRight,
-            takerAddress,
-            erc20BalancesByOwner,
-            erc721TokenIdsByOwner,
+            initialLeftOrderFilledAmount,
+            initialRightOrderFilledAmount,
             expectedTransferAmounts,
         );
-        // Assert our expected balances are equal to the actual balances
-        const didExpectedBalancesMatchRealBalances = MatchOrderTester._compareExpectedAndRealBalances(
-            expectedERC20BalancesByOwner,
+        // Assert balances of makers, taker, and fee recipients
+        await this._assertBalancesAsync(
+            signedOrderLeft,
+            signedOrderRight,
+            erc20BalancesByOwner,
+            erc721TokenIdsByOwner,
             newERC20BalancesByOwner,
-            expectedERC721TokenIdsByOwner,
             newERC721TokenIdsByOwner,
+            expectedTransferAmounts,
+            takerAddress,
         );
-        expect(didExpectedBalancesMatchRealBalances).to.be.true();
         return [newERC20BalancesByOwner, newERC721TokenIdsByOwner];
     }
-    /// @dev Calculates expected transfer amounts between order makers, fee recipients, and
-    ///      the taker when two orders are matched.
+    /// @dev Asserts initial exchange state for the left and right orders.
+    /// @param signedOrderLeft First matched order.
+    /// @param signedOrderRight Second matched order.
+    /// @param expectedOrderFilledAmountLeft How much left order has been filled, prior to matching orders.
+    /// @param expectedOrderFilledAmountRight How much the right order has been filled, prior to matching orders.
+    private async _assertInitialOrderStatesAsync(
+        signedOrderLeft: SignedOrder,
+        signedOrderRight: SignedOrder,
+        expectedOrderFilledAmountLeft: BigNumber,
+        expectedOrderFilledAmountRight: BigNumber,
+    ): Promise<void> {
+        // Assert left order initial state
+        const orderTakerAssetFilledAmountLeft = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
+            orderHashUtils.getOrderHashHex(signedOrderLeft),
+        );
+        expect(orderTakerAssetFilledAmountLeft, 'Checking inital state of left order').to.be.bignumber.equal(
+            expectedOrderFilledAmountLeft,
+        );
+        // Assert right order initial state
+        const orderTakerAssetFilledAmountRight = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
+            orderHashUtils.getOrderHashHex(signedOrderRight),
+        );
+        expect(orderTakerAssetFilledAmountRight, 'Checking inital state of right order').to.be.bignumber.equal(
+            expectedOrderFilledAmountRight,
+        );
+    }
+    /// @dev Asserts the exchange state against the expected amounts transferred by from matching orders.
     /// @param signedOrderLeft First matched order.
     /// @param signedOrderRight Second matched order.
-    /// @param orderTakerAssetFilledAmountLeft How much left order has been filled, prior to matching orders.
-    /// @param orderTakerAssetFilledAmountRight How much the right order has been filled, prior to matching orders.
+    /// @param initialLeftOrderFilledAmount How much left order has been filled, prior to matching orders.
+    /// @param initialRightOrderFilledAmount How much the right order has been filled, prior to matching orders.
     /// @return TransferAmounts A struct containing the expected transfer amounts.
-    private async _calculateExpectedTransferAmountsAsync(
+    private async _assertExchangeStateAsync(
         signedOrderLeft: SignedOrder,
         signedOrderRight: SignedOrder,
-        orderTakerAssetFilledAmountLeft: BigNumber,
-        orderTakerAssetFilledAmountRight: BigNumber,
-    ): Promise<TransferAmounts> {
+        initialLeftOrderFilledAmount: BigNumber,
+        initialRightOrderFilledAmount: BigNumber,
+        expectedTransferAmounts: TransferAmounts,
+    ): Promise<void> {
+        // Assert state for left order: amount bought by left maker
         let amountBoughtByLeftMaker = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
             orderHashUtils.getOrderHashHex(signedOrderLeft),
         );
-        amountBoughtByLeftMaker = amountBoughtByLeftMaker.minus(orderTakerAssetFilledAmountLeft);
-        const amountSoldByLeftMaker = amountBoughtByLeftMaker
-            .times(signedOrderLeft.makerAssetAmount)
-            .dividedToIntegerBy(signedOrderLeft.takerAssetAmount);
-        const amountReceivedByRightMaker = amountBoughtByLeftMaker
-            .times(signedOrderRight.takerAssetAmount)
-            .dividedToIntegerBy(signedOrderRight.makerAssetAmount);
-        const amountReceivedByTaker = amountSoldByLeftMaker.minus(amountReceivedByRightMaker);
+        amountBoughtByLeftMaker = amountBoughtByLeftMaker.minus(initialLeftOrderFilledAmount);
+        expect(amountBoughtByLeftMaker, 'Checking exchange state for left order').to.be.bignumber.equal(
+            expectedTransferAmounts.amountBoughtByLeftMaker,
+        );
+        // Assert state for right order: amount bought by right maker
         let amountBoughtByRightMaker = await this._exchangeWrapper.getTakerAssetFilledAmountAsync(
             orderHashUtils.getOrderHashHex(signedOrderRight),
         );
-        amountBoughtByRightMaker = amountBoughtByRightMaker.minus(orderTakerAssetFilledAmountRight);
-        const amountSoldByRightMaker = amountBoughtByRightMaker
-            .times(signedOrderRight.makerAssetAmount)
-            .dividedToIntegerBy(signedOrderRight.takerAssetAmount);
-        const amountReceivedByLeftMaker = amountSoldByRightMaker;
-        const feePaidByLeftMaker = signedOrderLeft.makerFee
-            .times(amountSoldByLeftMaker)
-            .dividedToIntegerBy(signedOrderLeft.makerAssetAmount);
-        const feePaidByRightMaker = signedOrderRight.makerFee
-            .times(amountSoldByRightMaker)
-            .dividedToIntegerBy(signedOrderRight.makerAssetAmount);
-        const feePaidByTakerLeft = signedOrderLeft.takerFee
-            .times(amountSoldByLeftMaker)
-            .dividedToIntegerBy(signedOrderLeft.makerAssetAmount);
-        const feePaidByTakerRight = signedOrderRight.takerFee
-            .times(amountSoldByRightMaker)
-            .dividedToIntegerBy(signedOrderRight.makerAssetAmount);
-        const totalFeePaidByTaker = feePaidByTakerLeft.add(feePaidByTakerRight);
-        const feeReceivedLeft = feePaidByLeftMaker.add(feePaidByTakerLeft);
-        const feeReceivedRight = feePaidByRightMaker.add(feePaidByTakerRight);
-        // Return values
-        const expectedTransferAmounts = {
-            // Left Maker
-            amountBoughtByLeftMaker,
-            amountSoldByLeftMaker,
-            amountReceivedByLeftMaker,
-            feePaidByLeftMaker,
-            // Right Maker
-            amountBoughtByRightMaker,
-            amountSoldByRightMaker,
-            amountReceivedByRightMaker,
-            feePaidByRightMaker,
-            // Taker
-            amountReceivedByTaker,
-            feePaidByTakerLeft,
-            feePaidByTakerRight,
-            totalFeePaidByTaker,
-            // Fee Recipients
-            feeReceivedLeft,
-            feeReceivedRight,
-        };
-        return expectedTransferAmounts;
+        amountBoughtByRightMaker = amountBoughtByRightMaker.minus(initialRightOrderFilledAmount);
+        expect(amountBoughtByRightMaker, 'Checking exchange state for right order').to.be.bignumber.equal(
+            expectedTransferAmounts.amountBoughtByRightMaker,
+        );
+        // Assert left order status
+        const maxAmountBoughtByLeftMaker = signedOrderLeft.takerAssetAmount.minus(initialLeftOrderFilledAmount);
+        const leftOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderLeft);
+        const leftExpectedStatus = expectedTransferAmounts.amountBoughtByLeftMaker.equals(maxAmountBoughtByLeftMaker)
+            ? OrderStatus.FULLY_FILLED
+            : OrderStatus.FILLABLE;
+        expect(leftOrderInfo.orderStatus as OrderStatus, 'Checking exchange status for left order').to.be.equal(
+            leftExpectedStatus,
+        );
+        // Assert right order status
+        const maxAmountBoughtByRightMaker = signedOrderRight.takerAssetAmount.minus(initialRightOrderFilledAmount);
+        const rightOrderInfo: OrderInfo = await this._exchangeWrapper.getOrderInfoAsync(signedOrderRight);
+        const rightExpectedStatus = expectedTransferAmounts.amountBoughtByRightMaker.equals(maxAmountBoughtByRightMaker)
+            ? OrderStatus.FULLY_FILLED
+            : OrderStatus.FILLABLE;
+        expect(rightOrderInfo.orderStatus as OrderStatus, 'Checking exchange status for right order').to.be.equal(
+            rightExpectedStatus,
+        );
+    }
+    /// @dev Asserts account balances after matching orders.
+    /// @param signedOrderLeft First matched order.
+    /// @param signedOrderRight Second matched order.
+    /// @param initialERC20BalancesByOwner ERC20 balances prior to order matching.
+    /// @param initialERC721TokenIdsByOwner ERC721 token owners prior to order matching.
+    /// @param finalERC20BalancesByOwner ERC20 balances after order matching.
+    /// @param finalERC721TokenIdsByOwner ERC721 token owners after order matching.
+    /// @param expectedTransferAmounts Expected amounts transferred as a result of order matching.
+    /// @param takerAddress Address of taker (account that called Exchange.matchOrders).
+    private async _assertBalancesAsync(
+        signedOrderLeft: SignedOrder,
+        signedOrderRight: SignedOrder,
+        initialERC20BalancesByOwner: ERC20BalancesByOwner,
+        initialERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
+        finalERC20BalancesByOwner: ERC20BalancesByOwner,
+        finalERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
+        expectedTransferAmounts: TransferAmounts,
+        takerAddress: string,
+    ): Promise<void> {
+        let expectedERC20BalancesByOwner: ERC20BalancesByOwner;
+        let expectedERC721TokenIdsByOwner: ERC721TokenIdsByOwner;
+        [expectedERC20BalancesByOwner, expectedERC721TokenIdsByOwner] = this._calculateExpectedBalances(
+            signedOrderLeft,
+            signedOrderRight,
+            takerAddress,
+            initialERC20BalancesByOwner,
+            initialERC721TokenIdsByOwner,
+            expectedTransferAmounts,
+        );
+        // Assert balances of makers, taker, and fee recipients
+        await this._assertMakerTakerAndFeeRecipientBalancesAsync(
+            signedOrderLeft,
+            signedOrderRight,
+            expectedERC20BalancesByOwner,
+            finalERC20BalancesByOwner,
+            expectedERC721TokenIdsByOwner,
+            finalERC721TokenIdsByOwner,
+            takerAddress,
+        );
+        // Assert balances for all known accounts
+        await MatchOrderTester._assertAllKnownBalancesAsync(
+            expectedERC20BalancesByOwner,
+            finalERC20BalancesByOwner,
+            expectedERC721TokenIdsByOwner,
+            finalERC721TokenIdsByOwner,
+        );
     }
     /// @dev Calculates the expected balances of order makers, fee recipients, and the taker,
     ///      as a result of matching two orders.
-    /// @param signedOrderLeft First matched order.
+    /// @param signedOrderRight First matched order.
     /// @param signedOrderRight Second matched order.
     /// @param takerAddress Address of taker (the address who matched the two orders)
     /// @param erc20BalancesByOwner Current ERC20 balances.
     /// @param erc721TokenIdsByOwner Current ERC721 token owners.
-    /// @param expectedTransferAmounts A struct containing the expected transfer amounts.
+    /// @param expectedTransferAmounts Expected amounts transferred as a result of order matching.
     /// @return Expected ERC20 balances & ERC721 token owners after orders have been matched.
     private _calculateExpectedBalances(
         signedOrderLeft: SignedOrder,
@@ -247,7 +369,7 @@ export class MatchOrderTester {
             expectedNewERC20BalancesByOwner[makerAddressRight][
                 takerAssetAddressRight
             ] = expectedNewERC20BalancesByOwner[makerAddressRight][takerAssetAddressRight].add(
-                expectedTransferAmounts.amountReceivedByRightMaker,
+                expectedTransferAmounts.amountBoughtByRightMaker,
             );
             // Taker
             expectedNewERC20BalancesByOwner[takerAddress][makerAssetAddressLeft] = expectedNewERC20BalancesByOwner[
@@ -277,7 +399,7 @@ export class MatchOrderTester {
             // Left Maker
             expectedNewERC20BalancesByOwner[makerAddressLeft][takerAssetAddressLeft] = expectedNewERC20BalancesByOwner[
                 makerAddressLeft
-            ][takerAssetAddressLeft].add(expectedTransferAmounts.amountReceivedByLeftMaker);
+            ][takerAssetAddressLeft].add(expectedTransferAmounts.amountBoughtByLeftMaker);
             // Right Maker
             expectedNewERC20BalancesByOwner[makerAddressRight][
                 makerAssetAddressRight
@@ -307,20 +429,138 @@ export class MatchOrderTester {
         // Taker Fees
         expectedNewERC20BalancesByOwner[takerAddress][this._feeTokenAddress] = expectedNewERC20BalancesByOwner[
             takerAddress
-        ][this._feeTokenAddress].minus(expectedTransferAmounts.totalFeePaidByTaker);
+        ][this._feeTokenAddress].minus(
+            expectedTransferAmounts.feePaidByTakerLeft.add(expectedTransferAmounts.feePaidByTakerRight),
+        );
         // Left Fee Recipient Fees
         expectedNewERC20BalancesByOwner[feeRecipientAddressLeft][
             this._feeTokenAddress
         ] = expectedNewERC20BalancesByOwner[feeRecipientAddressLeft][this._feeTokenAddress].add(
-            expectedTransferAmounts.feeReceivedLeft,
+            expectedTransferAmounts.feePaidByLeftMaker.add(expectedTransferAmounts.feePaidByTakerLeft),
         );
         // Right Fee Recipient Fees
         expectedNewERC20BalancesByOwner[feeRecipientAddressRight][
             this._feeTokenAddress
         ] = expectedNewERC20BalancesByOwner[feeRecipientAddressRight][this._feeTokenAddress].add(
-            expectedTransferAmounts.feeReceivedRight,
+            expectedTransferAmounts.feePaidByRightMaker.add(expectedTransferAmounts.feePaidByTakerRight),
         );
 
         return [expectedNewERC20BalancesByOwner, expectedNewERC721TokenIdsByOwner];
     }
-}
+    /// @dev Asserts ERC20 account balances and ERC721 token holdings that result from order matching.
+    ///      Specifically checks balances of makers, taker and fee recipients.
+    /// @param signedOrderLeft First matched order.
+    /// @param signedOrderRight Second matched order.
+    /// @param expectedERC20BalancesByOwner Expected ERC20 balances.
+    /// @param realERC20BalancesByOwner Real ERC20 balances.
+    /// @param expectedERC721TokenIdsByOwner Expected ERC721 token owners.
+    /// @param realERC721TokenIdsByOwner Real ERC20 token owners.
+    /// @param takerAddress Address of taker (account that called Exchange.matchOrders).
+    private async _assertMakerTakerAndFeeRecipientBalancesAsync(
+        signedOrderLeft: SignedOrder,
+        signedOrderRight: SignedOrder,
+        expectedERC20BalancesByOwner: ERC20BalancesByOwner,
+        realERC20BalancesByOwner: ERC20BalancesByOwner,
+        expectedERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
+        realERC721TokenIdsByOwner: ERC721TokenIdsByOwner,
+        takerAddress: string,
+    ): Promise<void> {
+        // Individual balance comparisons
+        const makerAssetProxyIdLeft = assetDataUtils.decodeAssetProxyId(signedOrderLeft.makerAssetData);
+        const makerERC20AssetDataLeft =
+            makerAssetProxyIdLeft === AssetProxyId.ERC20
+                ? assetDataUtils.decodeERC20AssetData(signedOrderLeft.makerAssetData)
+                : assetDataUtils.decodeERC721AssetData(signedOrderLeft.makerAssetData);
+        const makerAssetAddressLeft = makerERC20AssetDataLeft.tokenAddress;
+        const makerAssetProxyIdRight = assetDataUtils.decodeAssetProxyId(signedOrderRight.makerAssetData);
+        const makerERC20AssetDataRight =
+            makerAssetProxyIdRight === AssetProxyId.ERC20
+                ? assetDataUtils.decodeERC20AssetData(signedOrderRight.makerAssetData)
+                : assetDataUtils.decodeERC721AssetData(signedOrderRight.makerAssetData);
+        const makerAssetAddressRight = makerERC20AssetDataRight.tokenAddress;
+        if (makerAssetProxyIdLeft === AssetProxyId.ERC20) {
+            expect(
+                realERC20BalancesByOwner[signedOrderLeft.makerAddress][makerAssetAddressLeft],
+                'Checking left maker egress ERC20 account balance',
+            ).to.be.bignumber.equal(expectedERC20BalancesByOwner[signedOrderLeft.makerAddress][makerAssetAddressLeft]);
+            expect(
+                realERC20BalancesByOwner[signedOrderRight.makerAddress][makerAssetAddressLeft],
+                'Checking right maker ingress ERC20 account balance',
+            ).to.be.bignumber.equal(expectedERC20BalancesByOwner[signedOrderRight.makerAddress][makerAssetAddressLeft]);
+            expect(
+                realERC20BalancesByOwner[takerAddress][makerAssetAddressLeft],
+                'Checking taker ingress ERC20 account balance',
+            ).to.be.bignumber.equal(expectedERC20BalancesByOwner[takerAddress][makerAssetAddressLeft]);
+        } else if (makerAssetProxyIdLeft === AssetProxyId.ERC721) {
+            expect(
+                realERC721TokenIdsByOwner[signedOrderLeft.makerAddress][makerAssetAddressLeft].sort(),
+                'Checking left maker egress ERC721 account holdings',
+            ).to.be.deep.equal(
+                expectedERC721TokenIdsByOwner[signedOrderLeft.makerAddress][makerAssetAddressLeft].sort(),
+            );
+            expect(
+                realERC721TokenIdsByOwner[signedOrderRight.makerAddress][makerAssetAddressLeft].sort(),
+                'Checking right maker ERC721 account holdings',
+            ).to.be.deep.equal(
+                expectedERC721TokenIdsByOwner[signedOrderRight.makerAddress][makerAssetAddressLeft].sort(),
+            );
+            expect(
+                realERC721TokenIdsByOwner[takerAddress][makerAssetAddressLeft].sort(),
+                'Checking taker ingress ERC721 account holdings',
+            ).to.be.deep.equal(expectedERC721TokenIdsByOwner[takerAddress][makerAssetAddressLeft].sort());
+        } else {
+            throw new Error(`Unhandled Asset Proxy ID: ${makerAssetProxyIdLeft}`);
+        }
+        if (makerAssetProxyIdRight === AssetProxyId.ERC20) {
+            expect(
+                realERC20BalancesByOwner[signedOrderLeft.makerAddress][makerAssetAddressRight],
+                'Checking left maker ingress ERC20 account balance',
+            ).to.be.bignumber.equal(expectedERC20BalancesByOwner[signedOrderLeft.makerAddress][makerAssetAddressRight]);
+            expect(
+                realERC20BalancesByOwner[signedOrderRight.makerAddress][makerAssetAddressRight],
+                'Checking right maker egress ERC20 account balance',
+            ).to.be.bignumber.equal(
+                expectedERC20BalancesByOwner[signedOrderRight.makerAddress][makerAssetAddressRight],
+            );
+        } else if (makerAssetProxyIdRight === AssetProxyId.ERC721) {
+            expect(
+                realERC721TokenIdsByOwner[signedOrderLeft.makerAddress][makerAssetAddressRight].sort(),
+                'Checking left maker ingress ERC721 account holdings',
+            ).to.be.deep.equal(
+                expectedERC721TokenIdsByOwner[signedOrderLeft.makerAddress][makerAssetAddressRight].sort(),
+            );
+            expect(
+                realERC721TokenIdsByOwner[signedOrderRight.makerAddress][makerAssetAddressRight],
+                'Checking right maker agress ERC721 account holdings',
+            ).to.be.deep.equal(expectedERC721TokenIdsByOwner[signedOrderRight.makerAddress][makerAssetAddressRight]);
+        } else {
+            throw new Error(`Unhandled Asset Proxy ID: ${makerAssetProxyIdRight}`);
+        }
+        // Paid fees
+        expect(
+            realERC20BalancesByOwner[signedOrderLeft.makerAddress][this._feeTokenAddress],
+            'Checking left maker egress ERC20 account fees',
+        ).to.be.bignumber.equal(expectedERC20BalancesByOwner[signedOrderLeft.makerAddress][this._feeTokenAddress]);
+        expect(
+            realERC20BalancesByOwner[signedOrderRight.makerAddress][this._feeTokenAddress],
+            'Checking right maker egress ERC20 account fees',
+        ).to.be.bignumber.equal(expectedERC20BalancesByOwner[signedOrderRight.makerAddress][this._feeTokenAddress]);
+        expect(
+            realERC20BalancesByOwner[takerAddress][this._feeTokenAddress],
+            'Checking taker egress ERC20 account fees',
+        ).to.be.bignumber.equal(expectedERC20BalancesByOwner[takerAddress][this._feeTokenAddress]);
+        // Received fees
+        expect(
+            realERC20BalancesByOwner[signedOrderLeft.feeRecipientAddress][this._feeTokenAddress],
+            'Checking left fee recipient ingress ERC20 account fees',
+        ).to.be.bignumber.equal(
+            expectedERC20BalancesByOwner[signedOrderLeft.feeRecipientAddress][this._feeTokenAddress],
+        );
+        expect(
+            realERC20BalancesByOwner[signedOrderRight.feeRecipientAddress][this._feeTokenAddress],
+            'Checking right fee receipient ingress ERC20 account fees',
+        ).to.be.bignumber.equal(
+            expectedERC20BalancesByOwner[signedOrderRight.feeRecipientAddress][this._feeTokenAddress],
+        );
+    }
+} // tslint:disable-line:max-file-line-count
diff --git a/packages/contracts/test/utils/multi_sig_wrapper.ts b/packages/contracts/test/utils/multi_sig_wrapper.ts
index 8c8055d4a..e12a58695 100644
--- a/packages/contracts/test/utils/multi_sig_wrapper.ts
+++ b/packages/contracts/test/utils/multi_sig_wrapper.ts
@@ -6,7 +6,6 @@ import * as _ from 'lodash';
 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 {
@@ -16,7 +15,7 @@ export class MultiSigWrapper {
     constructor(multiSigContract: MultiSigWalletContract, provider: Provider) {
         this._multiSig = multiSigContract;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._multiSig.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async submitTransactionAsync(
         destination: string,
@@ -36,10 +35,19 @@ export class MultiSigWrapper {
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
     }
-    public async executeTransactionAsync(txId: BigNumber, from: string): Promise<TransactionReceiptWithDecodedLogs> {
+    public async revokeConfirmationAsync(txId: BigNumber, from: string): Promise<TransactionReceiptWithDecodedLogs> {
+        const txHash = await this._multiSig.revokeConfirmation.sendTransactionAsync(txId, { from });
+        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
+        return tx;
+    }
+    public async executeTransactionAsync(
+        txId: BigNumber,
+        from: string,
+        opts: { gas?: number } = {},
+    ): Promise<TransactionReceiptWithDecodedLogs> {
         const txHash = await this._multiSig.executeTransaction.sendTransactionAsync(txId, {
             from,
-            gas: constants.MAX_EXECUTE_TRANSACTION_GAS,
+            gas: opts.gas,
         });
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
@@ -52,7 +60,6 @@ export class MultiSigWrapper {
         const txHash = await (this
             ._multiSig as AssetProxyOwnerContract).executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
             from,
-            gas: constants.MAX_EXECUTE_TRANSACTION_GAS,
         });
         const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
         return tx;
diff --git a/packages/contracts/test/utils/order_factory_from_scenario.ts b/packages/contracts/test/utils/order_factory_from_scenario.ts
index a908140b9..8e04db588 100644
--- a/packages/contracts/test/utils/order_factory_from_scenario.ts
+++ b/packages/contracts/test/utils/order_factory_from_scenario.ts
@@ -21,6 +21,8 @@ const POINT_ONE_UNITS_EIGHTEEN_DECIMALS = new BigNumber(100_000_000_000_000_000)
 const POINT_ZERO_FIVE_UNITS_EIGHTEEN_DECIMALS = new BigNumber(50_000_000_000_000_000);
 const TEN_UNITS_FIVE_DECIMALS = new BigNumber(1_000_000);
 const FIVE_UNITS_FIVE_DECIMALS = new BigNumber(500_000);
+const TEN_UNITS_ZERO_DECIMALS = new BigNumber(10);
+const ONE_THOUSAND_UNITS_ZERO_DECIMALS = new BigNumber(1000);
 const ONE_NFT_UNIT = new BigNumber(1);
 
 export class OrderFactoryFromScenario {
@@ -28,6 +30,7 @@ export class OrderFactoryFromScenario {
     private readonly _zrxAddress: string;
     private readonly _nonZrxERC20EighteenDecimalTokenAddresses: string[];
     private readonly _erc20FiveDecimalTokenAddresses: string[];
+    private readonly _erc20ZeroDecimalTokenAddresses: string[];
     private readonly _erc721Token: DummyERC721TokenContract;
     private readonly _erc721Balances: ERC721TokenIdsByOwner;
     private readonly _exchangeAddress: string;
@@ -36,6 +39,7 @@ export class OrderFactoryFromScenario {
         zrxAddress: string,
         nonZrxERC20EighteenDecimalTokenAddresses: string[],
         erc20FiveDecimalTokenAddresses: string[],
+        erc20ZeroDecimalTokenAddresses: string[],
         erc721Token: DummyERC721TokenContract,
         erc721Balances: ERC721TokenIdsByOwner,
         exchangeAddress: string,
@@ -44,6 +48,7 @@ export class OrderFactoryFromScenario {
         this._zrxAddress = zrxAddress;
         this._nonZrxERC20EighteenDecimalTokenAddresses = nonZrxERC20EighteenDecimalTokenAddresses;
         this._erc20FiveDecimalTokenAddresses = erc20FiveDecimalTokenAddresses;
+        this._erc20ZeroDecimalTokenAddresses = erc20ZeroDecimalTokenAddresses;
         this._erc721Token = erc721Token;
         this._erc721Balances = erc721Balances;
         this._exchangeAddress = exchangeAddress;
@@ -89,6 +94,9 @@ export class OrderFactoryFromScenario {
                     erc721MakerAssetIds[0],
                 );
                 break;
+            case AssetDataScenario.ERC20ZeroDecimals:
+                makerAssetData = assetDataUtils.encodeERC20AssetData(this._erc20ZeroDecimalTokenAddresses[0]);
+                break;
             default:
                 throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.makerAssetDataScenario);
         }
@@ -109,6 +117,9 @@ export class OrderFactoryFromScenario {
                     erc721TakerAssetIds[0],
                 );
                 break;
+            case AssetDataScenario.ERC20ZeroDecimals:
+                takerAssetData = assetDataUtils.encodeERC20AssetData(this._erc20ZeroDecimalTokenAddresses[1]);
+                break;
             default:
                 throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.takerAssetDataScenario);
         }
@@ -126,6 +137,9 @@ export class OrderFactoryFromScenario {
                     case AssetDataScenario.ERC721:
                         makerAssetAmount = ONE_NFT_UNIT;
                         break;
+                    case AssetDataScenario.ERC20ZeroDecimals:
+                        makerAssetAmount = ONE_THOUSAND_UNITS_ZERO_DECIMALS;
+                        break;
                     default:
                         throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.makerAssetDataScenario);
                 }
@@ -142,6 +156,9 @@ export class OrderFactoryFromScenario {
                     case AssetDataScenario.ERC721:
                         makerAssetAmount = ONE_NFT_UNIT;
                         break;
+                    case AssetDataScenario.ERC20ZeroDecimals:
+                        makerAssetAmount = TEN_UNITS_ZERO_DECIMALS;
+                        break;
                     default:
                         throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.makerAssetDataScenario);
                 }
@@ -166,6 +183,9 @@ export class OrderFactoryFromScenario {
                     case AssetDataScenario.ERC721:
                         takerAssetAmount = ONE_NFT_UNIT;
                         break;
+                    case AssetDataScenario.ERC20ZeroDecimals:
+                        takerAssetAmount = ONE_THOUSAND_UNITS_ZERO_DECIMALS;
+                        break;
                     default:
                         throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.takerAssetDataScenario);
                 }
@@ -182,6 +202,9 @@ export class OrderFactoryFromScenario {
                     case AssetDataScenario.ERC721:
                         takerAssetAmount = ONE_NFT_UNIT;
                         break;
+                    case AssetDataScenario.ERC20ZeroDecimals:
+                        takerAssetAmount = TEN_UNITS_ZERO_DECIMALS;
+                        break;
                     default:
                         throw errorUtils.spawnSwitchErr('AssetDataScenario', orderScenario.takerAssetDataScenario);
                 }
diff --git a/packages/contracts/test/utils/order_utils.ts b/packages/contracts/test/utils/order_utils.ts
index 019f6e74b..444e27c44 100644
--- a/packages/contracts/test/utils/order_utils.ts
+++ b/packages/contracts/test/utils/order_utils.ts
@@ -5,7 +5,7 @@ import { constants } from './constants';
 import { CancelOrder, MatchOrder } from './types';
 
 export const orderUtils = {
-    getPartialAmount(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber {
+    getPartialAmountFloor(numerator: BigNumber, denominator: BigNumber, target: BigNumber): BigNumber {
         const partialAmount = numerator
             .mul(target)
             .div(denominator)
diff --git a/packages/contracts/test/utils/test_with_reference.ts b/packages/contracts/test/utils/test_with_reference.ts
index 599b1eed4..b80be4a6c 100644
--- a/packages/contracts/test/utils/test_with_reference.ts
+++ b/packages/contracts/test/utils/test_with_reference.ts
@@ -6,6 +6,34 @@ import { chaiSetup } from './chai_setup';
 chaiSetup.configure();
 const expect = chai.expect;
 
+class Value<T> {
+    public value: T;
+    constructor(value: T) {
+        this.value = value;
+    }
+}
+
+// tslint:disable-next-line: max-classes-per-file
+class ErrorMessage {
+    public error: string;
+    constructor(message: string) {
+        this.error = message;
+    }
+}
+
+type PromiseResult<T> = Value<T> | ErrorMessage;
+
+// TODO(albrow): This seems like a generic utility function that could exist in
+// lodash. We should replace it by a library implementation, or move it to our
+// own.
+async function evaluatePromise<T>(promise: Promise<T>): Promise<PromiseResult<T>> {
+    try {
+        return new Value<T>(await promise);
+    } catch (e) {
+        return new ErrorMessage(e.message);
+    }
+}
+
 export async function testWithReferenceFuncAsync<P0, R>(
     referenceFunc: (p0: P0) => Promise<R>,
     testFunc: (p0: P0) => Promise<R>,
@@ -64,39 +92,31 @@ export async function testWithReferenceFuncAsync(
     testFuncAsync: (...args: any[]) => Promise<any>,
     values: any[],
 ): Promise<void> {
-    let expectedResult: any;
-    let expectedErr: string | undefined;
-    try {
-        expectedResult = await referenceFuncAsync(...values);
-    } catch (e) {
-        expectedErr = e.message;
-    }
-    let actualResult: any | undefined;
-    try {
-        actualResult = await testFuncAsync(...values);
-        if (!_.isUndefined(expectedErr)) {
+    // Measure correct behaviour
+    const expected = await evaluatePromise(referenceFuncAsync(...values));
+
+    // Measure actual behaviour
+    const actual = await evaluatePromise(testFuncAsync(...values));
+
+    // Compare behaviour
+    if (expected instanceof ErrorMessage) {
+        // If we expected an error, check if the actual error message contains the
+        // expected error message.
+        if (!(actual instanceof ErrorMessage)) {
             throw new Error(
-                `Expected error containing ${expectedErr} but got no error\n\tTest case: ${_getTestCaseString(
+                `Expected error containing ${expected.error} but got no error\n\tTest case: ${_getTestCaseString(
                     referenceFuncAsync,
                     values,
                 )}`,
             );
         }
-    } catch (e) {
-        if (_.isUndefined(expectedErr)) {
-            throw new Error(`${e.message}\n\tTest case: ${_getTestCaseString(referenceFuncAsync, values)}`);
-        } else {
-            expect(e.message).to.contain(
-                expectedErr,
-                `${e.message}\n\tTest case: ${_getTestCaseString(referenceFuncAsync, values)}`,
-            );
-        }
-    }
-    if (!_.isUndefined(actualResult) && !_.isUndefined(expectedResult)) {
-        expect(actualResult).to.deep.equal(
-            expectedResult,
-            `Test case: ${_getTestCaseString(referenceFuncAsync, values)}`,
+        expect(actual.error).to.contain(
+            expected.error,
+            `${actual.error}\n\tTest case: ${_getTestCaseString(referenceFuncAsync, values)}`,
         );
+    } else {
+        // If we do not expect an error, compare actual and expected directly.
+        expect(actual).to.deep.equal(expected, `Test case ${_getTestCaseString(referenceFuncAsync, values)}`);
     }
 }
 
diff --git a/packages/contracts/test/utils/transaction_factory.ts b/packages/contracts/test/utils/transaction_factory.ts
index 281c1e30d..8465a6a30 100644
--- a/packages/contracts/test/utils/transaction_factory.ts
+++ b/packages/contracts/test/utils/transaction_factory.ts
@@ -1,4 +1,4 @@
-import { EIP712Schema, EIP712Types, EIP712Utils, generatePseudoRandomSalt } from '@0xproject/order-utils';
+import { EIP712Schema, EIP712Types, eip712Utils, generatePseudoRandomSalt } from '@0xproject/order-utils';
 import { SignatureType } from '@0xproject/types';
 import * as ethUtil from 'ethereumjs-util';
 
@@ -31,11 +31,11 @@ export class TransactionFactory {
             signerAddress,
             data,
         };
-        const executeTransactionHashBuff = EIP712Utils.structHash(
+        const executeTransactionHashBuff = eip712Utils.structHash(
             EIP712_ZEROEX_TRANSACTION_SCHEMA,
             executeTransactionData,
         );
-        const txHash = EIP712Utils.createEIP712Message(executeTransactionHashBuff, this._exchangeAddress);
+        const txHash = eip712Utils.createEIP712Message(executeTransactionHashBuff, this._exchangeAddress);
         const signature = signingUtils.signMessage(txHash, this._privateKey, signatureType);
         const signedTx = {
             exchangeAddress: this._exchangeAddress,
diff --git a/packages/contracts/test/utils/types.ts b/packages/contracts/test/utils/types.ts
index 67313b647..598fb5393 100644
--- a/packages/contracts/test/utils/types.ts
+++ b/packages/contracts/test/utils/types.ts
@@ -117,21 +117,24 @@ export interface TransferAmountsByMatchOrders {
     // Left Maker
     amountBoughtByLeftMaker: BigNumber;
     amountSoldByLeftMaker: BigNumber;
-    amountReceivedByLeftMaker: BigNumber;
     feePaidByLeftMaker: BigNumber;
     // Right Maker
     amountBoughtByRightMaker: BigNumber;
     amountSoldByRightMaker: BigNumber;
-    amountReceivedByRightMaker: BigNumber;
     feePaidByRightMaker: BigNumber;
     // Taker
     amountReceivedByTaker: BigNumber;
     feePaidByTakerLeft: BigNumber;
     feePaidByTakerRight: BigNumber;
-    totalFeePaidByTaker: BigNumber;
-    // Fee Recipients
-    feeReceivedLeft: BigNumber;
-    feeReceivedRight: BigNumber;
+}
+
+export interface TransferAmountsLoggedByMatchOrders {
+    makerAddress: string;
+    takerAddress: string;
+    makerAssetFilledAmount: string;
+    takerAssetFilledAmount: string;
+    makerFeePaid: string;
+    takerFeePaid: string;
 }
 
 export interface OrderInfo {
@@ -177,10 +180,11 @@ export enum ExpirationTimeSecondsScenario {
 }
 
 export enum AssetDataScenario {
-    ERC721 = 'ERC721',
+    ERC20ZeroDecimals = 'ERC20_ZERO_DECIMALS',
     ZRXFeeToken = 'ZRX_FEE_TOKEN',
     ERC20FiveDecimals = 'ERC20_FIVE_DECIMALS',
     ERC20NonZRXEighteenDecimals = 'ERC20_NON_ZRX_EIGHTEEN_DECIMALS',
+    ERC721 = 'ERC721',
 }
 
 export enum TakerAssetFillAmountScenario {
diff --git a/packages/contracts/test/utils/web3_wrapper.ts b/packages/contracts/test/utils/web3_wrapper.ts
index acb3103b7..d1cd3d387 100644
--- a/packages/contracts/test/utils/web3_wrapper.ts
+++ b/packages/contracts/test/utils/web3_wrapper.ts
@@ -1,5 +1,5 @@
 import { devConstants, env, EnvVars, web3Factory } from '@0xproject/dev-utils';
-import { prependSubprovider } from '@0xproject/subproviders';
+import { prependSubprovider, Web3ProviderEngine } from '@0xproject/subproviders';
 import { logUtils } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as _ from 'lodash';
@@ -47,7 +47,7 @@ const ganacheConfigs = {
 };
 const providerConfigs = testProvider === ProviderType.Ganache ? ganacheConfigs : gethConfigs;
 
-export const provider = web3Factory.getRpcProvider(providerConfigs);
+export const provider: Web3ProviderEngine = web3Factory.getRpcProvider(providerConfigs);
 const isCoverageEnabled = env.parseBoolean(EnvVars.SolidityCoverage);
 const isProfilerEnabled = env.parseBoolean(EnvVars.SolidityProfiler);
 const isRevertTraceEnabled = env.parseBoolean(EnvVars.SolidityRevertTrace);
diff --git a/packages/contracts/test/utils_test/test_with_reference.ts b/packages/contracts/test/utils_test/test_with_reference.ts
new file mode 100644
index 000000000..8d633cd1f
--- /dev/null
+++ b/packages/contracts/test/utils_test/test_with_reference.ts
@@ -0,0 +1,63 @@
+import * as chai from 'chai';
+
+import { chaiSetup } from '../utils/chai_setup';
+import { testWithReferenceFuncAsync } from '../utils/test_with_reference';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+async function divAsync(x: number, y: number): Promise<number> {
+    if (y === 0) {
+        throw new Error('MathError: divide by zero');
+    }
+    return x / y;
+}
+
+// returns an async function that always returns the given value.
+function alwaysValueFunc(value: number): (x: number, y: number) => Promise<number> {
+    return async (x: number, y: number) => value;
+}
+
+// returns an async function which always throws/rejects with the given error
+// message.
+function alwaysFailFunc(errMessage: string): (x: number, y: number) => Promise<number> {
+    return async (x: number, y: number) => {
+        throw new Error(errMessage);
+    };
+}
+
+describe('testWithReferenceFuncAsync', () => {
+    it('passes when both succeed and actual === expected', async () => {
+        await testWithReferenceFuncAsync(alwaysValueFunc(0.5), divAsync, [1, 2]);
+    });
+
+    it('passes when both fail and actual error contains expected error', async () => {
+        await testWithReferenceFuncAsync(alwaysFailFunc('divide by zero'), divAsync, [1, 0]);
+    });
+
+    it('fails when both succeed and actual !== expected', async () => {
+        expect(testWithReferenceFuncAsync(alwaysValueFunc(3), divAsync, [1, 2])).to.be.rejectedWith(
+            'Test case {"x":1,"y":2}: expected { value: 0.5 } to deeply equal { value: 3 }',
+        );
+    });
+
+    it('fails when both fail and actual error does not contain expected error', async () => {
+        expect(
+            testWithReferenceFuncAsync(alwaysFailFunc('Unexpected math error'), divAsync, [1, 0]),
+        ).to.be.rejectedWith(
+            'MathError: divide by zero\n\tTest case: {"x":1,"y":0}: expected \'MathError: divide by zero\' to include \'Unexpected math error\'',
+        );
+    });
+
+    it('fails when referenceFunc succeeds and testFunc fails', async () => {
+        expect(testWithReferenceFuncAsync(alwaysValueFunc(0), divAsync, [1, 0])).to.be.rejectedWith(
+            'Test case {"x":1,"y":0}: expected { error: \'MathError: divide by zero\' } to deeply equal { value: 0 }',
+        );
+    });
+
+    it('fails when referenceFunc fails and testFunc succeeds', async () => {
+        expect(testWithReferenceFuncAsync(alwaysFailFunc('divide by zero'), divAsync, [1, 2])).to.be.rejectedWith(
+            'Expected error containing divide by zero but got no error\n\tTest case: {"x":1,"y":2}',
+        );
+    });
+});