From 78d81f193f3b9358ab86819f83c76b8bcd52a9c9 Mon Sep 17 00:00:00 2001 From: Greg Hysen Date: Tue, 10 Apr 2018 17:53:34 -0700 Subject: Asset Proxy Dispatcher --- .../test/asset_proxy_dispatcher/dispatcher.ts | 339 ++++++++++++++ .../test/asset_proxy_dispatcher/proxies.ts | 407 +++++++++++++++++ packages/contracts/test/exchange/core.ts | 503 ++++++++++++++++++++- packages/contracts/test/exchange/helpers.ts | 47 +- packages/contracts/test/exchange/wrapper.ts | 90 +++- 5 files changed, 1366 insertions(+), 20 deletions(-) create mode 100644 packages/contracts/test/asset_proxy_dispatcher/dispatcher.ts create mode 100644 packages/contracts/test/asset_proxy_dispatcher/proxies.ts (limited to 'packages/contracts/test') 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(); -- cgit v1.2.3