Asset Proxy Dispatcher

5 files changed, 1366 insertions, 20 deletions

diff --git a/packages/contracts/test/asset_proxy_dispatcher/dispatcher.ts b/packages/contracts/test/asset_proxy_dispatcher/dispatcher.ts
new file mode 100644
index 000000000..6cb9f2bc1
--- /dev/null
+++ b/packages/contracts/test/asset_proxy_dispatcher/dispatcher.ts
@@ -0,0 +1,339 @@
+import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs, ZeroEx } from '0x.js';
+import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as chai from 'chai';
+import * as Web3 from 'web3';
+
+import { AssetProxyDispatcherContract } from '../../src/contract_wrappers/generated/asset_proxy_dispatcher';
+import { DummyERC721TokenContract } from '../../src/contract_wrappers/generated/dummy_e_r_c721_token';
+import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { ERC20TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c20_transfer_proxy';
+import { ERC721TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c721_transfer_proxy';
+import { ERC20TransferProxy_v1Contract } from '../../src/contract_wrappers/generated/erc20transferproxy_v1';
+import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
+import {
+    encodeERC20ProxyMetadata,
+    encodeERC20ProxyMetadata_V1,
+    encodeERC721ProxyMetadata,
+} from '../../src/utils/asset_proxy_utils';
+import { Balances } from '../../src/utils/balances';
+import { constants } from '../../src/utils/constants';
+import { AssetProxyId, ContractName } from '../../src/utils/types';
+import { chaiSetup } from '../utils/chai_setup';
+import { deployer } from '../utils/deployer';
+import { provider, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('AssetProxyDispatcher', () => {
+    let owner: string;
+    let notOwner: string;
+    let assetProxyManagerAddress: string;
+    let tokenOwner: string;
+    let makerAddress: string;
+    let takerAddress: string;
+    let zrx: DummyTokenContract;
+    let dmyBalances: Balances;
+    let tokenTransferProxy: TokenTransferProxyContract;
+    let assetProxyDispatcher: AssetProxyDispatcherContract;
+    let erc20TransferProxyV1: ERC20TransferProxy_v1Contract;
+    let erc20TransferProxy: ERC20TransferProxyContract;
+    let erc721TransferProxy: ERC721TransferProxyContract;
+    const nilAddress = '0x0000000000000000000000000000000000000000';
+    const INITIAL_BALANCE = new BigNumber(10000);
+
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = tokenOwner = accounts[0];
+        notOwner = accounts[1];
+        assetProxyManagerAddress = accounts[2];
+        makerAddress = accounts[3];
+        takerAddress = accounts[4];
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(
+            tokenTransferProxyInstance.abi,
+            tokenTransferProxyInstance.address,
+            provider,
+        );
+
+        const erc20TransferProxyV1Instance = await deployer.deployAsync(ContractName.ERC20TransferProxy_V1, [
+            tokenTransferProxy.address,
+        ]);
+        erc20TransferProxyV1 = new ERC20TransferProxy_v1Contract(
+            erc20TransferProxyV1Instance.abi,
+            erc20TransferProxyV1Instance.address,
+            provider,
+        );
+
+        const erc20TransferProxyInstance = await deployer.deployAsync(ContractName.ERC20TransferProxy);
+        erc20TransferProxy = new ERC20TransferProxyContract(
+            erc20TransferProxyInstance.abi,
+            erc20TransferProxyInstance.address,
+            provider,
+        );
+
+        const erc721TransferProxyInstance = await deployer.deployAsync(ContractName.ERC721TransferProxy);
+        erc721TransferProxy = new ERC721TransferProxyContract(
+            erc721TransferProxyInstance.abi,
+            erc721TransferProxyInstance.address,
+            provider,
+        );
+
+        const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
+        assetProxyDispatcher = new AssetProxyDispatcherContract(
+            assetProxyDispatcherInstance.abi,
+            assetProxyDispatcherInstance.address,
+            provider,
+        );
+
+        const zrxInstance = await deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS);
+        zrx = new DummyTokenContract(zrxInstance.abi, zrxInstance.address, provider);
+        await zrx.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner });
+        await zrx.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner });
+        dmyBalances = new Balances([zrx], [makerAddress, takerAddress]);
+        await zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_BALANCE, {
+            from: takerAddress,
+        });
+        await zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_BALANCE, {
+            from: makerAddress,
+        });
+
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await erc20TransferProxyV1.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc20TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc721TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(erc20TransferProxyV1.address, {
+            from: accounts[0],
+        });
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('setAssetProxy', () => {
+        it('should record proxy upon registration', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            const proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+        });
+
+        it('should be able to record multiple proxies', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            let proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC721,
+                erc721TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC721);
+            expect(proxyAddress).to.be.equal(erc721TransferProxy.address);
+        });
+
+        it('should replace proxy address upon re-registration', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            let proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+
+            // Deploy a new version of the ERC20 Transfer Proxy contract
+            const newErc20TransferProxyInstance = await deployer.deployAsync(ContractName.ERC20TransferProxy);
+            const newErc20TransferProxy = new ERC20TransferProxyContract(
+                newErc20TransferProxyInstance.abi,
+                newErc20TransferProxyInstance.address,
+                provider,
+            );
+
+            const newAddress = newErc20TransferProxy.address;
+            const currentAddress = erc20TransferProxy.address;
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                newAddress,
+                currentAddress,
+                { from: owner },
+            );
+            proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(newAddress);
+        });
+
+        it('should throw if registering with incorrect "old_address" field', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            const proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+
+            // The following transaction will throw because the currentAddress is no longer nilAddress
+            return expect(
+                assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                    AssetProxyId.ERC20,
+                    erc20TransferProxy.address,
+                    nilAddress,
+                    { from: owner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should be able to reset proxy address to NULL', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            const proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+
+            // The following transaction will reset the proxy address
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                nilAddress,
+                erc20TransferProxy.address,
+                { from: owner },
+            );
+            const newProxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(newProxyAddress).to.be.equal(nilAddress);
+        });
+
+        it('should throw if requesting address is not authorized', async () => {
+            return expect(
+                assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                    AssetProxyId.ERC20,
+                    erc20TransferProxy.address,
+                    nilAddress,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+    });
+
+    describe('getAssetProxy', () => {
+        it('should return correct address of registered proxy', async () => {
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+            const proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(erc20TransferProxy.address);
+        });
+
+        it('should return NULL address if requesting non-existent proxy', async () => {
+            const proxyAddress = await assetProxyDispatcher.getAssetProxy.callAsync(AssetProxyId.ERC20);
+            expect(proxyAddress).to.be.equal(nilAddress);
+        });
+    });
+
+    describe('transferFrom', () => {
+        it('should dispatch  transfer to registered proxy', async () => {
+            // Register ERC20 proxy
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            await assetProxyDispatcher.transferFrom.sendTransactionAsync(
+                encodedProxyMetadata,
+                makerAddress,
+                takerAddress,
+                amount,
+                { from: assetProxyManagerAddress },
+            );
+
+            // Verify transfer was successful
+            const newBalances = await dmyBalances.getAsync();
+            expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[makerAddress][zrx.address].minus(amount),
+            );
+            expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[takerAddress][zrx.address].add(amount),
+            );
+        });
+
+        it('should throw if delegating to unregistered proxy', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            return expect(
+                assetProxyDispatcher.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw if requesting address is not authorized', async () => {
+            // Register ERC20 proxy
+            await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+                AssetProxyId.ERC20,
+                erc20TransferProxy.address,
+                nilAddress,
+                { from: owner },
+            );
+
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            return expect(
+                assetProxyDispatcher.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+    });
+});
diff --git a/packages/contracts/test/asset_proxy_dispatcher/proxies.ts b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts
new file mode 100644
index 000000000..da1bb170c
--- /dev/null
+++ b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts
@@ -0,0 +1,407 @@
+import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs, ZeroEx } from '0x.js';
+import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as chai from 'chai';
+import * as Web3 from 'web3';
+
+import { AssetProxyDispatcherContract } from '../../src/contract_wrappers/generated/asset_proxy_dispatcher';
+import { DummyERC721TokenContract } from '../../src/contract_wrappers/generated/dummy_e_r_c721_token';
+import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { ERC20TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c20_transfer_proxy';
+import { ERC721TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c721_transfer_proxy';
+import { ERC20TransferProxy_v1Contract } from '../../src/contract_wrappers/generated/erc20transferproxy_v1';
+import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
+import {
+    encodeERC20ProxyMetadata,
+    encodeERC20ProxyMetadata_V1,
+    encodeERC721ProxyMetadata,
+} from '../../src/utils/asset_proxy_utils';
+import { Balances } from '../../src/utils/balances';
+import { constants } from '../../src/utils/constants';
+import { AssetProxyId, ContractName } from '../../src/utils/types';
+import { chaiSetup } from '../utils/chai_setup';
+import { deployer } from '../utils/deployer';
+import { provider, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('Asset Transfer Proxies', () => {
+    let owner: string;
+    let notOwner: string;
+    let assetProxyManagerAddress: string;
+    let tokenOwner: string;
+    let makerAddress: string;
+    let takerAddress: string;
+    let zrx: DummyTokenContract;
+    let ck: DummyERC721TokenContract;
+    let dmyBalances: Balances;
+    let tokenTransferProxy: TokenTransferProxyContract;
+    let assetProxyDispatcher: AssetProxyDispatcherContract;
+    let erc20TransferProxyV1: ERC20TransferProxy_v1Contract;
+    let erc20TransferProxy: ERC20TransferProxyContract;
+    let erc721TransferProxy: ERC721TransferProxyContract;
+    const nilAddress = '0x0000000000000000000000000000000000000000';
+    const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+    const INITIAL_BALANCE = new BigNumber(10000);
+
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = tokenOwner = accounts[0];
+        notOwner = accounts[1];
+        assetProxyManagerAddress = accounts[2];
+        makerAddress = accounts[3];
+        takerAddress = accounts[4];
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(
+            tokenTransferProxyInstance.abi,
+            tokenTransferProxyInstance.address,
+            provider,
+        );
+
+        const erc20TransferProxyV1Instance = await deployer.deployAsync(ContractName.ERC20TransferProxy_V1, [
+            tokenTransferProxy.address,
+        ]);
+        erc20TransferProxyV1 = new ERC20TransferProxy_v1Contract(
+            erc20TransferProxyV1Instance.abi,
+            erc20TransferProxyV1Instance.address,
+            provider,
+        );
+
+        const erc20TransferProxyInstance = await deployer.deployAsync(ContractName.ERC20TransferProxy);
+        erc20TransferProxy = new ERC20TransferProxyContract(
+            erc20TransferProxyInstance.abi,
+            erc20TransferProxyInstance.address,
+            provider,
+        );
+
+        const erc721TransferProxyInstance = await deployer.deployAsync(ContractName.ERC721TransferProxy);
+        erc721TransferProxy = new ERC721TransferProxyContract(
+            erc721TransferProxyInstance.abi,
+            erc721TransferProxyInstance.address,
+            provider,
+        );
+
+        const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
+        assetProxyDispatcher = new AssetProxyDispatcherContract(
+            assetProxyDispatcherInstance.abi,
+            assetProxyDispatcherInstance.address,
+            provider,
+        );
+
+        const zrxInstance = await deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS);
+        zrx = new DummyTokenContract(zrxInstance.abi, zrxInstance.address, provider);
+        await zrx.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner });
+        await zrx.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner });
+        dmyBalances = new Balances([zrx], [makerAddress, takerAddress]);
+        await zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_BALANCE, {
+            from: takerAddress,
+        });
+        await zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_BALANCE, {
+            from: makerAddress,
+        });
+        await zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_BALANCE, {
+            from: takerAddress,
+        });
+        await zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_BALANCE, {
+            from: makerAddress,
+        });
+
+        const ckInstance = await deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721TOKEN_ARGS);
+        ck = new DummyERC721TokenContract(ckInstance.abi, ckInstance.address, provider);
+        await ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: makerAddress });
+        await ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: takerAddress });
+        await ck.mint.sendTransactionAsync(makerAddress, makerTokenId, { from: tokenOwner });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await erc20TransferProxyV1.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await erc20TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await erc721TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(erc20TransferProxyV1.address, {
+            from: accounts[0],
+        });
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('Transfer Proxy - ERC20_V1', () => {
+        it('should successfully encode/decode metadata', async () => {
+            const metadata = await erc20TransferProxyV1.encodeMetadata.callAsync(AssetProxyId.ERC20_V1, zrx.address);
+            const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(zrx.address);
+        });
+
+        it('should successfully decode metadata encoded by typescript helpers', async () => {
+            const metadata = encodeERC20ProxyMetadata_V1(zrx.address);
+            const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(zrx.address);
+        });
+
+        it('should successfully encode/decode metadata padded with zeros', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = await erc20TransferProxyV1.encodeMetadata.callAsync(AssetProxyId.ERC20_V1, testAddress);
+            const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+        });
+
+        it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = encodeERC20ProxyMetadata_V1(testAddress);
+            const address = await erc20TransferProxyV1.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+        });
+
+        it('should successfully transfer tokens', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata_V1(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            await erc20TransferProxyV1.transferFrom.sendTransactionAsync(
+                encodedProxyMetadata,
+                makerAddress,
+                takerAddress,
+                amount,
+                { from: assetProxyManagerAddress },
+            );
+
+            // Verify transfer was successful
+            const newBalances = await dmyBalances.getAsync();
+            expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[makerAddress][zrx.address].minus(amount),
+            );
+            expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[takerAddress][zrx.address].add(amount),
+            );
+        });
+
+        it('should throw if requesting address is not authorized', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata_V1(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            expect(
+                erc20TransferProxyV1.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+    });
+
+    describe('Transfer Proxy - ERC20', () => {
+        it('should successfully encode/decode metadata', async () => {
+            const metadata = await erc20TransferProxy.encodeMetadata.callAsync(AssetProxyId.ERC20, zrx.address);
+            const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(zrx.address);
+        });
+
+        it('should successfully decode metadata encoded by typescript helpers', async () => {
+            const metadata = encodeERC20ProxyMetadata(zrx.address);
+            const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(zrx.address);
+        });
+
+        it('should successfully encode/decode metadata padded with zeros', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = await erc20TransferProxy.encodeMetadata.callAsync(AssetProxyId.ERC20, testAddress);
+            const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+        });
+
+        it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = encodeERC20ProxyMetadata(testAddress);
+            const address = await erc20TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+        });
+
+        it('should successfully transfer tokens', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            await erc20TransferProxy.transferFrom.sendTransactionAsync(
+                encodedProxyMetadata,
+                makerAddress,
+                takerAddress,
+                amount,
+                { from: assetProxyManagerAddress },
+            );
+
+            // Verify transfer was successful
+            const newBalances = await dmyBalances.getAsync();
+            expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[makerAddress][zrx.address].minus(amount),
+            );
+            expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[takerAddress][zrx.address].add(amount),
+            );
+        });
+
+        it('should throw if requesting address is not authorized', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC20ProxyMetadata(zrx.address);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(10);
+            expect(
+                erc20TransferProxy.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+    });
+
+    describe('Transfer Proxy - ERC721', () => {
+        it('should successfully encode/decode metadata', async () => {
+            const metadata = await erc721TransferProxy.encodeMetadata.callAsync(
+                AssetProxyId.ERC721,
+                ck.address,
+                makerTokenId,
+            );
+            const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(ck.address);
+            expect(tokenId).to.be.bignumber.equal(makerTokenId);
+        });
+
+        it('should successfully decode metadata encoded by typescript helpers', async () => {
+            const metadata = encodeERC721ProxyMetadata(ck.address, makerTokenId);
+            const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(ck.address);
+            expect(tokenId).to.be.bignumber.equal(makerTokenId);
+        });
+
+        it('should successfully encode/decode metadata padded with zeros', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = await erc721TransferProxy.encodeMetadata.callAsync(
+                AssetProxyId.ERC721,
+                testAddress,
+                makerTokenId,
+            );
+            const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+            expect(tokenId).to.be.bignumber.equal(makerTokenId);
+        });
+
+        it('should successfully decode metadata encoded padded with zeros by typescript helpers', async () => {
+            const testAddress = '0x0000000000000000056000000000000000000010';
+            const metadata = encodeERC721ProxyMetadata(testAddress, makerTokenId);
+            const [address, tokenId] = await erc721TransferProxy.decodeMetadata.callAsync(metadata);
+            expect(address).to.be.equal(testAddress);
+            expect(tokenId).to.be.bignumber.equal(makerTokenId);
+        });
+
+        it('should successfully transfer tokens', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC721ProxyMetadata(ck.address, makerTokenId);
+
+            // Verify pre-condition
+            const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(1);
+            await erc721TransferProxy.transferFrom.sendTransactionAsync(
+                encodedProxyMetadata,
+                makerAddress,
+                takerAddress,
+                amount,
+                { from: assetProxyManagerAddress },
+            );
+
+            // Verify transfer was successful
+            const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
+        });
+
+        it('should throw if transferring 0 amount of a token', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC721ProxyMetadata(ck.address, makerTokenId);
+
+            // Verify pre-condition
+            const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(0);
+            expect(
+                erc20TransferProxy.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw if transferring >1 amount of a token', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC721ProxyMetadata(ck.address, makerTokenId);
+
+            // Verify pre-condition
+            const ownerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(500);
+            expect(
+                erc20TransferProxy.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw if requesting address is not authorized', async () => {
+            // Construct metadata for ERC20 proxy
+            const encodedProxyMetadata = encodeERC721ProxyMetadata(zrx.address, makerTokenId);
+
+            // Perform a transfer from makerAddress to takerAddress
+            const balances = await dmyBalances.getAsync();
+            const amount = new BigNumber(1);
+            expect(
+                erc20TransferProxy.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: notOwner },
+                ),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+    });
+});
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index ef3b3b9ee..1277a88f3 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -1,13 +1,18 @@
 import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs, ZeroEx } from '0x.js';
-
 import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils';
 import { BigNumber } from '@0xproject/utils';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import ethUtil = require('ethereumjs-util');
+import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
+import { AssetProxyDispatcherContract } from '../../src/contract_wrappers/generated/asset_proxy_dispatcher';
+import { DummyERC721TokenContract } from '../../src/contract_wrappers/generated/dummy_e_r_c721_token';
 import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { ERC20TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c20_transfer_proxy';
+import { ERC721TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c721_transfer_proxy';
+import { ERC20TransferProxy_v1Contract } from '../../src/contract_wrappers/generated/erc20transferproxy_v1';
 import {
     CancelContractEventArgs,
     ExchangeContract,
@@ -15,13 +20,25 @@ import {
     FillContractEventArgs,
 } from '../../src/contract_wrappers/generated/exchange';
 import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
+import {
+    encodeERC20ProxyMetadata,
+    encodeERC20ProxyMetadata_V1,
+    encodeERC721ProxyMetadata,
+} from '../../src/utils/asset_proxy_utils';
 import { Balances } from '../../src/utils/balances';
 import { constants } from '../../src/utils/constants';
 import { crypto } from '../../src/utils/crypto';
 import { ExchangeWrapper } from '../../src/utils/exchange_wrapper';
 import { OrderFactory } from '../../src/utils/order_factory';
 import { orderUtils } from '../../src/utils/order_utils';
-import { BalancesByOwner, ContractName, ExchangeContractErrs, SignatureType, SignedOrder } from '../../src/utils/types';
+import {
+    AssetProxyId,
+    BalancesByOwner,
+    ContractName,
+    ExchangeContractErrs,
+    SignatureType,
+    SignedOrder,
+} from '../../src/utils/types';
 import { chaiSetup } from '../utils/chai_setup';
 import { deployer } from '../utils/deployer';
 import { provider, web3Wrapper } from '../utils/web3_wrapper';
@@ -35,14 +52,21 @@ describe('Exchange', () => {
     let tokenOwner: string;
     let takerAddress: string;
     let feeRecipientAddress: string;
+    let assetProxyManagerAddress: string;
     const INITIAL_BALANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
     const INITIAL_ALLOWANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
 
     let rep: DummyTokenContract;
     let dgd: DummyTokenContract;
     let zrx: DummyTokenContract;
+    let ck: DummyERC721TokenContract;
+    let et: DummyERC721TokenContract;
     let exchange: ExchangeContract;
     let tokenTransferProxy: TokenTransferProxyContract;
+    let assetProxyDispatcher: AssetProxyDispatcherContract;
+    let erc20TransferProxyV1: ERC20TransferProxy_v1Contract;
+    let erc20TransferProxy: ERC20TransferProxyContract;
+    let erc721TransferProxy: ERC721TransferProxyContract;
 
     let signedOrder: SignedOrder;
     let balances: BalancesByOwner;
@@ -50,32 +74,104 @@ describe('Exchange', () => {
     let dmyBalances: Balances;
     let orderFactory: OrderFactory;
 
+    let erc721TransferProxyInstance: Web3.ContractInstance;
+
     let zeroEx: ZeroEx;
 
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         makerAddress = accounts[0];
-        [tokenOwner, takerAddress, feeRecipientAddress] = accounts;
-        const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
+        [tokenOwner, takerAddress, feeRecipientAddress, assetProxyManagerAddress] = accounts;
+        const [repInstance, dgdInstance, zrxInstance, ckInstance, etInstance] = await Promise.all([
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
+            deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721TOKEN_ARGS),
+            deployer.deployAsync(ContractName.DummyERC721Token, constants.DUMMY_ERC721TOKEN_ARGS),
         ]);
         rep = new DummyTokenContract(repInstance.abi, repInstance.address, provider);
         dgd = new DummyTokenContract(dgdInstance.abi, dgdInstance.address, provider);
         zrx = new DummyTokenContract(zrxInstance.abi, zrxInstance.address, provider);
+        ck = new DummyERC721TokenContract(ckInstance.abi, ckInstance.address, provider);
+        et = new DummyERC721TokenContract(etInstance.abi, etInstance.address, provider);
         const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
         tokenTransferProxy = new TokenTransferProxyContract(
             tokenTransferProxyInstance.abi,
             tokenTransferProxyInstance.address,
             provider,
         );
+
+        const erc20TransferProxyV1Instance = await deployer.deployAsync(ContractName.ERC20TransferProxy_V1, [
+            tokenTransferProxy.address,
+        ]);
+        erc20TransferProxyV1 = new ERC20TransferProxy_v1Contract(
+            erc20TransferProxyV1Instance.abi,
+            erc20TransferProxyV1Instance.address,
+            provider,
+        );
+
+        const erc20TransferProxyInstance = await deployer.deployAsync(ContractName.ERC20TransferProxy);
+        erc20TransferProxy = new ERC20TransferProxyContract(
+            erc20TransferProxyInstance.abi,
+            erc20TransferProxyInstance.address,
+            provider,
+        );
+
+        erc721TransferProxyInstance = await deployer.deployAsync(ContractName.ERC721TransferProxy);
+        erc721TransferProxy = new ERC721TransferProxyContract(
+            erc721TransferProxyInstance.abi,
+            erc721TransferProxyInstance.address,
+            provider,
+        );
+
+        const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
+        assetProxyDispatcher = new AssetProxyDispatcherContract(
+            assetProxyDispatcherInstance.abi,
+            assetProxyDispatcherInstance.address,
+            provider,
+        );
+
         const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
             zrx.address,
-            tokenTransferProxy.address,
+            encodeERC20ProxyMetadata(zrx.address),
+            assetProxyDispatcher.address,
         ]);
         exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
-        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
+        await erc20TransferProxyV1.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc20TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc721TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(erc20TransferProxyV1.address, {
+            from: accounts[0],
+        });
+        const nilAddress = '0x0000000000000000000000000000000000000000';
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20_V1,
+            erc20TransferProxyV1.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20,
+            erc20TransferProxy.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC721,
+            erc721TransferProxy.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
         zeroEx = new ZeroEx(provider, {
             exchangeContractAddress: exchange.address,
             networkId: constants.TESTRPC_NETWORK_ID,
@@ -92,6 +188,8 @@ describe('Exchange', () => {
             takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerAssetProxyData: encodeERC20ProxyMetadata(rep.address),
+            takerAssetProxyData: encodeERC20ProxyMetadata(dgd.address),
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);
@@ -103,6 +201,12 @@ describe('Exchange', () => {
             rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: takerAddress,
             }),
+            rep.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: makerAddress,
+            }),
+            rep.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: takerAddress,
+            }),
             rep.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             rep.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
@@ -111,6 +215,12 @@ describe('Exchange', () => {
             dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: takerAddress,
             }),
+            dgd.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: makerAddress,
+            }),
+            dgd.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: takerAddress,
+            }),
             dgd.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             dgd.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
@@ -119,8 +229,109 @@ describe('Exchange', () => {
             zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: takerAddress,
             }),
+            zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: makerAddress,
+            }),
+            zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
+                from: takerAddress,
+            }),
             zrx.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             zrx.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
+
+            // Distribute ck ERC721 tokens to maker & taker
+            // maker owns [0x1010.., ... , 0x4040..] and taker owns [0x5050.., ..., 0x9090..]
+            ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: makerAddress }),
+            ck.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: takerAddress }),
+            ck.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x3030303030303030303030303030303030303030303030303030303030303030'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x4040404040404040404040404040404040404040404040404040404040404040'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x5050505050505050505050505050505050505050505050505050505050505050'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x6060606060606060606060606060606060606060606060606060606060606060'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x7070707070707070707070707070707070707070707070707070707070707070'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x8080808080808080808080808080808080808080808080808080808080808080'),
+                { from: tokenOwner },
+            ),
+            ck.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090'),
+                { from: tokenOwner },
+            ),
+
+            // Distribute et ERC721 tokens to maker & taker
+            // maker owns [0x1010.., ... , 0x4040..] and taker owns [0x5050.., ..., 0x9090..]
+            et.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: makerAddress }),
+            et.setApprovalForAll.sendTransactionAsync(erc721TransferProxy.address, true, { from: takerAddress }),
+            et.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                makerAddress,
+                new BigNumber('0x3030303030303030303030303030303030303030303030303030303030303030'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x5050505050505050505050505050505050505050505050505050505050505050'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x6060606060606060606060606060606060606060606060606060606060606060'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x7070707070707070707070707070707070707070707070707070707070707070'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x8080808080808080808080808080808080808080808080808080808080808080'),
+                { from: tokenOwner },
+            ),
+            et.mint.sendTransactionAsync(
+                takerAddress,
+                new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090'),
+                { from: tokenOwner },
+            ),
         ]);
     });
     beforeEach(async () => {
@@ -749,4 +960,284 @@ describe('Exchange', () => {
             );
         });
     });
+
+    describe('Testing Exchange of ERC721 Tokens', () => {
+        it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(1),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+
+            // Verify post-conditions
+            const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
+            const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
+        });
+
+        it('should successfully exchange a single token between the maker and taker (via filleOrderNoThrow)', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(1),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+
+            // Verify post-conditions
+            const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
+            const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
+        });
+
+        it('should throw when maker does not own the token with id makerTokenId', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x5050505050505050505050505050505050505050505050505050505050505050');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(1),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.not.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            return expect(
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw when taker does not own the token with id takerTokenId', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x2020202020202020202020202020202020202020202020202020202020202020');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(1),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.not.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            return expect(
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw when makerTokenAmount is greater than 1', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(2),
+                takerTokenAmount: new BigNumber(1),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            return expect(
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw when takerTokenAmount is greater than 1', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(500),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            return expect(
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should throw on partial fill', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: ck.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: new BigNumber(0),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            return expect(
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+            ).to.be.rejectedWith(constants.REVERT);
+        });
+
+        it('should successfully fill order when makerToken is ERC721 and takerToken is ERC20', async () => {
+            // Construct Exchange parameters
+            const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+            signedOrder = orderFactory.newSignedOrder({
+                makerTokenAddress: ck.address,
+                takerTokenAddress: dgd.address,
+                makerTokenAmount: new BigNumber(1),
+                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetProxyData: encodeERC721ProxyMetadata(ck.address, makerTokenId),
+                takerAssetProxyData: encodeERC20ProxyMetadata(dgd.address),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
+
+            // Call Exchange
+            balances = await dmyBalances.getAsync();
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+
+            // Verify ERC721 token was transferred from Maker to Taker
+            const newOwnerMakerToken = await ck.ownerOf.callAsync(makerTokenId);
+            expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Verify ERC20 tokens were transferred from Taker to Maker & fees were paid correctly
+            const newBalances = await dmyBalances.getAsync();
+            expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+            );
+            expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+            );
+            expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
+            );
+            expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[takerAddress][zrx.address].minus(signedOrder.takerFee),
+            );
+            expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
+                balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)),
+            );
+        });
+
+        it('should successfully fill order when makerToken is ERC20 and takerToken is ERC721', async () => {
+            // Construct Exchange parameters
+            const takerTokenId = new BigNumber('0x9090909090909090909090909090909090909090909090909090909090909090');
+            signedOrder = orderFactory.newSignedOrder({
+                takerTokenAddress: ck.address,
+                makerTokenAddress: dgd.address,
+                takerTokenAmount: new BigNumber(1),
+                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetProxyData: encodeERC721ProxyMetadata(ck.address, takerTokenId),
+                makerAssetProxyData: encodeERC20ProxyMetadata(dgd.address),
+            });
+
+            // Verify pre-conditions
+            const initialOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
+
+            // Call Exchange
+            balances = await dmyBalances.getAsync();
+            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+
+            // Verify ERC721 token was transferred from Taker to Maker
+            const newOwnerTakerToken = await ck.ownerOf.callAsync(takerTokenId);
+            expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
+
+            // Verify ERC20 tokens were transferred from Maker to Taker & fees were paid correctly
+            const newBalances = await dmyBalances.getAsync();
+            expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
+                balances[takerAddress][signedOrder.makerTokenAddress].add(signedOrder.makerTokenAmount),
+            );
+            expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(signedOrder.makerTokenAmount),
+            );
+            expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
+            );
+            expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
+                balances[takerAddress][zrx.address].minus(signedOrder.takerFee),
+            );
+            expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
+                balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)),
+            );
+        });
+    });
 }); // tslint:disable-line:max-file-line-count
diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts
index 4fa55efa1..37e53630e 100644
--- a/packages/contracts/test/exchange/helpers.ts
+++ b/packages/contracts/test/exchange/helpers.ts
@@ -6,11 +6,16 @@ import * as chai from 'chai';
 import ethUtil = require('ethereumjs-util');
 
 import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
+import {
+    encodeERC20ProxyMetadata,
+    encodeERC20ProxyMetadata_V1,
+    encodeERC721ProxyMetadata,
+} from '../../src/utils/asset_proxy_utils';
 import { constants } from '../../src/utils/constants';
 import { ExchangeWrapper } from '../../src/utils/exchange_wrapper';
 import { OrderFactory } from '../../src/utils/order_factory';
 import { orderUtils } from '../../src/utils/order_utils';
-import { ContractName, SignedOrder } from '../../src/utils/types';
+import { AssetProxyId, ContractName, SignedOrder } from '../../src/utils/types';
 import { chaiSetup } from '../utils/chai_setup';
 import { deployer } from '../utils/deployer';
 import { provider, web3Wrapper } from '../utils/web3_wrapper';
@@ -23,6 +28,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 describe('Exchange', () => {
     let makerAddress: string;
     let feeRecipientAddress: string;
+    let assetProxyManagerAddress: string;
 
     let signedOrder: SignedOrder;
     let exchangeWrapper: ExchangeWrapper;
@@ -30,9 +36,14 @@ describe('Exchange', () => {
 
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
-        [makerAddress, feeRecipientAddress] = accounts;
+        [makerAddress, feeRecipientAddress, assetProxyManagerAddress] = accounts;
         const tokenRegistry = await deployer.deployAsync(ContractName.TokenRegistry);
         const tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        const assetProxyDispatcher = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
+        const erc20TransferProxyV1 = await deployer.deployAsync(ContractName.ERC20TransferProxy_V1, [
+            tokenTransferProxy.address,
+        ]);
+        const erc20TransferProxy = await deployer.deployAsync(ContractName.ERC20TransferProxy);
         const [rep, dgd, zrx] = await Promise.all([
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
@@ -40,10 +51,36 @@ describe('Exchange', () => {
         ]);
         const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
             zrx.address,
-            tokenTransferProxy.address,
+            AssetProxyId.ERC20,
+            assetProxyDispatcher.address,
         ]);
         const exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
-        await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
+        await erc20TransferProxyV1.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc20TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(erc20TransferProxyV1.address, {
+            from: accounts[0],
+        });
+        const nilAddress = '0x0000000000000000000000000000000000000000';
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20_V1,
+            erc20TransferProxyV1.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20,
+            erc20TransferProxy.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
         const zeroEx = new ZeroEx(provider, { networkId: constants.TESTRPC_NETWORK_ID });
         exchangeWrapper = new ExchangeWrapper(exchange, zeroEx);
         const defaultOrderParams = {
@@ -56,6 +93,8 @@ describe('Exchange', () => {
             takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerAssetProxyData: encodeERC20ProxyMetadata(rep.address),
+            takerAssetProxyData: encodeERC20ProxyMetadata(dgd.address),
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index 0ba74e1e9..a58568adb 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -6,15 +6,23 @@ import * as chai from 'chai';
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
+import { AssetProxyDispatcherContract } from '../../src/contract_wrappers/generated/asset_proxy_dispatcher';
 import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { ERC20TransferProxyContract } from '../../src/contract_wrappers/generated/e_r_c20_transfer_proxy';
+import { ERC20TransferProxy_v1Contract } from '../../src/contract_wrappers/generated/erc20transferproxy_v1';
 import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
 import { TokenRegistryContract } from '../../src/contract_wrappers/generated/token_registry';
 import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
+import {
+    encodeERC20ProxyMetadata,
+    encodeERC20ProxyMetadata_V1,
+    encodeERC721ProxyMetadata,
+} from '../../src/utils/asset_proxy_utils';
 import { Balances } from '../../src/utils/balances';
 import { constants } from '../../src/utils/constants';
 import { ExchangeWrapper } from '../../src/utils/exchange_wrapper';
 import { OrderFactory } from '../../src/utils/order_factory';
-import { BalancesByOwner, ContractName, SignedOrder } from '../../src/utils/types';
+import { AssetProxyId, BalancesByOwner, ContractName, SignedOrder } from '../../src/utils/types';
 import { chaiSetup } from '../utils/chai_setup';
 import { deployer } from '../utils/deployer';
 import { provider, web3Wrapper } from '../utils/web3_wrapper';
@@ -28,6 +36,7 @@ describe('Exchange', () => {
     let tokenOwner: string;
     let takerAddress: string;
     let feeRecipientAddress: string;
+    let assetProxyManagerAddress: string;
 
     const INITIAL_BALANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
     const INITIAL_ALLOWANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
@@ -38,6 +47,9 @@ describe('Exchange', () => {
     let exchange: ExchangeContract;
     let tokenRegistry: TokenRegistryContract;
     let tokenTransferProxy: TokenTransferProxyContract;
+    let assetProxyDispatcher: AssetProxyDispatcherContract;
+    let erc20TransferProxyV1: ERC20TransferProxy_v1Contract;
+    let erc20TransferProxy: ERC20TransferProxyContract;
 
     let balances: BalancesByOwner;
 
@@ -48,7 +60,7 @@ describe('Exchange', () => {
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         tokenOwner = accounts[0];
-        [makerAddress, takerAddress, feeRecipientAddress] = accounts;
+        [makerAddress, takerAddress, feeRecipientAddress, assetProxyManagerAddress] = accounts;
         const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
             deployer.deployAsync(ContractName.DummyToken, constants.DUMMY_TOKEN_ARGS),
@@ -65,12 +77,58 @@ describe('Exchange', () => {
             tokenTransferProxyInstance.address,
             provider,
         );
+        const erc20TransferProxyV1Instance = await deployer.deployAsync(ContractName.ERC20TransferProxy_V1, [
+            tokenTransferProxy.address,
+        ]);
+        erc20TransferProxyV1 = new ERC20TransferProxy_v1Contract(
+            erc20TransferProxyV1Instance.abi,
+            erc20TransferProxyV1Instance.address,
+            provider,
+        );
+        const erc20TransferProxyInstance = await deployer.deployAsync(ContractName.ERC20TransferProxy);
+        erc20TransferProxy = new ERC20TransferProxyContract(
+            erc20TransferProxyInstance.abi,
+            erc20TransferProxyInstance.address,
+            provider,
+        );
+        const assetProxyDispatcherInstance = await deployer.deployAsync(ContractName.AssetProxyDispatcher);
+        assetProxyDispatcher = new AssetProxyDispatcherContract(
+            assetProxyDispatcherInstance.abi,
+            assetProxyDispatcherInstance.address,
+            provider,
+        );
         const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
             zrx.address,
-            tokenTransferProxy.address,
+            encodeERC20ProxyMetadata(zrx.address),
+            assetProxyDispatcher.address,
         ]);
         exchange = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
-        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(assetProxyManagerAddress, {
+            from: accounts[0],
+        });
+        await assetProxyDispatcher.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
+        await erc20TransferProxyV1.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await erc20TransferProxy.addAuthorizedAddress.sendTransactionAsync(assetProxyDispatcher.address, {
+            from: accounts[0],
+        });
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(erc20TransferProxyV1.address, {
+            from: accounts[0],
+        });
+        const nilAddress = '0x0000000000000000000000000000000000000000';
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20_V1,
+            erc20TransferProxyV1.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
+        await assetProxyDispatcher.setAssetProxy.sendTransactionAsync(
+            AssetProxyId.ERC20,
+            erc20TransferProxy.address,
+            nilAddress,
+            { from: accounts[0] },
+        );
         const zeroEx = new ZeroEx(provider, { networkId: constants.TESTRPC_NETWORK_ID });
         exWrapper = new ExchangeWrapper(exchange, zeroEx);
 
@@ -84,6 +142,8 @@ describe('Exchange', () => {
             takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerAssetProxyData: encodeERC20ProxyMetadata(rep.address),
+            takerAssetProxyData: encodeERC20ProxyMetadata(dgd.address),
         };
 
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
@@ -92,14 +152,20 @@ describe('Exchange', () => {
         await Promise.all([
             rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
             rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
+            rep.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
+            rep.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
             rep.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             rep.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
             dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
+            dgd.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
+            dgd.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
             dgd.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             dgd.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
             zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
+            zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: makerAddress }),
+            zrx.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, { from: takerAddress }),
             zrx.setBalance.sendTransactionAsync(makerAddress, INITIAL_BALANCE, { from: tokenOwner }),
             zrx.setBalance.sendTransactionAsync(takerAddress, INITIAL_BALANCE, { from: tokenOwner }),
         ]);
@@ -246,11 +312,11 @@ describe('Exchange', () => {
 
         it('should not change balances if maker allowances are too low to fill order', async () => {
             const signedOrder = orderFactory.newSignedOrder();
-            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), {
+            await rep.approve.sendTransactionAsync(erc20TransferProxy.address, new BigNumber(0), {
                 from: makerAddress,
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
-            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await rep.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
                 from: makerAddress,
             });
 
@@ -260,11 +326,11 @@ describe('Exchange', () => {
 
         it('should not change balances if taker allowances are too low to fill order', async () => {
             const signedOrder = orderFactory.newSignedOrder();
-            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), {
+            await dgd.approve.sendTransactionAsync(erc20TransferProxy.address, new BigNumber(0), {
                 from: takerAddress,
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
-            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await dgd.approve.sendTransactionAsync(erc20TransferProxy.address, INITIAL_ALLOWANCE, {
                 from: takerAddress,
             });
 
@@ -278,6 +344,7 @@ describe('Exchange', () => {
                 makerTokenAddress: zrx.address,
                 makerTokenAmount: makerZRXBalance,
                 makerFee: new BigNumber(1),
+                makerAssetProxyData: encodeERC20ProxyMetadata(zrx.address),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
@@ -285,11 +352,12 @@ describe('Exchange', () => {
         });
 
         it('should not change balances if makerTokenAddress is ZRX, makerTokenAmount + makerFee > maker allowance', async () => {
-            const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, tokenTransferProxy.address);
+            const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, erc20TransferProxy.address);
             const signedOrder = orderFactory.newSignedOrder({
                 makerTokenAddress: zrx.address,
                 makerTokenAmount: new BigNumber(makerZRXAllowance),
                 makerFee: new BigNumber(1),
+                makerAssetProxyData: encodeERC20ProxyMetadata(zrx.address),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
@@ -302,6 +370,7 @@ describe('Exchange', () => {
                 takerTokenAddress: zrx.address,
                 takerTokenAmount: takerZRXBalance,
                 takerFee: new BigNumber(1),
+                takerAssetProxyData: encodeERC20ProxyMetadata(zrx.address),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
@@ -309,11 +378,12 @@ describe('Exchange', () => {
         });
 
         it('should not change balances if takerTokenAddress is ZRX, takerTokenAmount + takerFee > taker allowance', async () => {
-            const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, tokenTransferProxy.address);
+            const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, erc20TransferProxy.address);
             const signedOrder = orderFactory.newSignedOrder({
                 takerTokenAddress: zrx.address,
                 takerTokenAmount: new BigNumber(takerZRXAllowance),
                 takerFee: new BigNumber(1),
+                takerAssetProxyData: encodeERC20ProxyMetadata(zrx.address),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();