Add tests for batchTransferFrom

1 files changed, 296 insertions, 151 deletions

diff --git a/packages/contracts/test/asset_proxy/proxies.ts b/packages/contracts/test/asset_proxy/proxies.ts
index bdd0a8696..a304da585 100644
--- a/packages/contracts/test/asset_proxy/proxies.ts
+++ b/packages/contracts/test/asset_proxy/proxies.ts
@@ -2,6 +2,7 @@ import { ZeroEx } from '0x.js';
 import { BlockchainLifecycle } from '@0xproject/dev-utils';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
+import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
 import { DummyERC20TokenContract } from '../../src/contract_wrappers/generated/dummy_e_r_c20_token';
@@ -37,6 +38,8 @@ describe('Asset Transfer Proxies', () => {
     let erc721Wrapper: ERC721Wrapper;
     let erc721MakerTokenId: BigNumber;
 
+    let zeroEx: ZeroEx;
+
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         const usedAddresses = ([owner, notAuthorized, exchangeAddress, makerAddress, takerAddress] = accounts);
@@ -59,6 +62,10 @@ describe('Asset Transfer Proxies', () => {
         await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(exchangeAddress, {
             from: owner,
         });
+
+        zeroEx = new ZeroEx(provider, {
+            networkId: constants.TESTRPC_NETWORK_ID,
+        });
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -67,83 +74,143 @@ describe('Asset Transfer Proxies', () => {
         await blockchainLifecycle.revertAsync();
     });
     describe('Transfer Proxy - ERC20', () => {
-        it('should successfully transfer tokens', async () => {
-            // Construct metadata for ERC20 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
-            // Perform a transfer from makerAddress to takerAddress
-            const erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const amount = new BigNumber(10);
-            await erc20Proxy.transferFrom.sendTransactionAsync(
-                encodedProxyMetadata,
-                makerAddress,
-                takerAddress,
-                amount,
-                { from: exchangeAddress },
-            );
-            // Verify transfer was successful
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(amount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].add(amount),
-            );
-        });
-
-        it('should do nothing if transferring 0 amount of a token', async () => {
-            // Construct metadata for ERC20 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
-            // Perform a transfer from makerAddress to takerAddress
-            const erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const amount = new BigNumber(0);
-            await erc20Proxy.transferFrom.sendTransactionAsync(
-                encodedProxyMetadata,
-                makerAddress,
-                takerAddress,
-                amount,
-                { from: exchangeAddress },
-            );
-            // Verify transfer was successful
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address],
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address],
-            );
-        });
-
-        it('should throw if allowances are too low', async () => {
-            // Construct metadata for ERC20 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
-            // Create allowance less than transfer amount. Set allowance on proxy.
-            const allowance = new BigNumber(0);
-            const transferAmount = new BigNumber(10);
-            await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
-                from: makerAddress,
+        describe('transferFrom', () => {
+            it('should successfully transfer tokens', async () => {
+                // Construct metadata for ERC20 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(10);
+                await erc20Proxy.transferFrom.sendTransactionAsync(
+                    encodedProxyMetadata,
+                    makerAddress,
+                    takerAddress,
+                    amount,
+                    { from: exchangeAddress },
+                );
+                // Verify transfer was successful
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[makerAddress][zrxToken.address].minus(amount),
+                );
+                expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[takerAddress][zrxToken.address].add(amount),
+                );
             });
-            // Perform a transfer; expect this to fail.
-            return expect(
-                erc20Proxy.transferFrom.sendTransactionAsync(
+
+            it('should do nothing if transferring 0 amount of a token', async () => {
+                // Construct metadata for ERC20 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(0);
+                await erc20Proxy.transferFrom.sendTransactionAsync(
                     encodedProxyMetadata,
                     makerAddress,
                     takerAddress,
-                    transferAmount,
-                    { from: notAuthorized },
-                ),
-            ).to.be.rejectedWith(constants.REVERT);
+                    amount,
+                    { from: exchangeAddress },
+                );
+                // Verify transfer was successful
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+                expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[makerAddress][zrxToken.address],
+                );
+                expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[takerAddress][zrxToken.address],
+                );
+            });
+
+            it('should throw if allowances are too low', async () => {
+                // Construct metadata for ERC20 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                // Create allowance less than transfer amount. Set allowance on proxy.
+                const allowance = new BigNumber(0);
+                const transferAmount = new BigNumber(10);
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                    from: makerAddress,
+                });
+                // Perform a transfer; expect this to fail.
+                return expect(
+                    erc20Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        transferAmount,
+                        { from: notAuthorized },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
+
+            it('should throw if requesting address is not authorized', async () => {
+                // Construct metadata for ERC20 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                // Perform a transfer from makerAddress to takerAddress
+                const amount = new BigNumber(10);
+                return expect(
+                    erc20Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        amount,
+                        {
+                            from: notAuthorized,
+                        },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
         });
 
-        it('should throw if requesting address is not authorized', async () => {
-            // Construct metadata for ERC20 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
-            // Perform a transfer from makerAddress to takerAddress
-            const amount = new BigNumber(10);
-            return expect(
-                erc20Proxy.transferFrom.sendTransactionAsync(encodedProxyMetadata, makerAddress, takerAddress, amount, {
-                    from: notAuthorized,
-                }),
-            ).to.be.rejectedWith(constants.REVERT);
+        describe('batchTransferFrom', () => {
+            it('should succesfully make multiple token transfers', async () => {
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                const amount = new BigNumber(10);
+                const numTransfers = 2;
+                const assetMetadata = _.times(numTransfers, () => encodedProxyMetadata);
+                const fromAddresses = _.times(numTransfers, () => makerAddress);
+                const toAddresses = _.times(numTransfers, () => takerAddress);
+                const amounts = _.times(numTransfers, () => amount);
+
+                const txHash = await erc20Proxy.batchTransferFrom.sendTransactionAsync(
+                    assetMetadata,
+                    fromAddresses,
+                    toAddresses,
+                    amounts,
+                    { from: exchangeAddress },
+                );
+                const res = await zeroEx.awaitTransactionMinedAsync(txHash);
+                const newBalances = await erc20Wrapper.getBalancesAsync();
+
+                expect(res.logs.length).to.equal(numTransfers);
+                expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[makerAddress][zrxToken.address].minus(amount.times(numTransfers)),
+                );
+                expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
+                    erc20Balances[takerAddress][zrxToken.address].add(amount.times(numTransfers)),
+                );
+            });
+
+            it('should throw if not called by an authorized address', async () => {
+                const encodedProxyMetadata = assetProxyUtils.encodeERC20ProxyData(zrxToken.address);
+                const amount = new BigNumber(10);
+                const numTransfers = 2;
+                const assetMetadata = _.times(numTransfers, () => encodedProxyMetadata);
+                const fromAddresses = _.times(numTransfers, () => makerAddress);
+                const toAddresses = _.times(numTransfers, () => takerAddress);
+                const amounts = _.times(numTransfers, () => amount);
+
+                expect(
+                    erc20Proxy.batchTransferFrom.sendTransactionAsync(
+                        assetMetadata,
+                        fromAddresses,
+                        toAddresses,
+                        amounts,
+                        { from: notAuthorized },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
         });
 
         it('should have an id of 1', async () => {
@@ -153,97 +220,175 @@ describe('Asset Transfer Proxies', () => {
     });
 
     describe('Transfer Proxy - ERC721', () => {
-        it('should successfully transfer tokens', async () => {
-            // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(erc721Token.address, erc721MakerTokenId);
-            // Verify pre-condition
-            const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-            expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
-            // Perform a transfer from makerAddress to takerAddress
-            const erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const amount = new BigNumber(1);
-            await erc721Proxy.transferFrom.sendTransactionAsync(
-                encodedProxyMetadata,
-                makerAddress,
-                takerAddress,
-                amount,
-                { from: exchangeAddress },
-            );
-            // Verify transfer was successful
-            const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-            expect(newOwnerMakerAsset).to.be.bignumber.equal(takerAddress);
-        });
-
-        it('should throw if transferring 0 amount of a token', async () => {
-            // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(erc721Token.address, erc721MakerTokenId);
-            // Verify pre-condition
-            const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-            expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
-            // Perform a transfer from makerAddress to takerAddress
-            const erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const amount = new BigNumber(0);
-            return expect(
-                erc721Proxy.transferFrom.sendTransactionAsync(
+        describe('transferFrom', () => {
+            it('should successfully transfer tokens', async () => {
+                // Construct metadata for ERC721 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                );
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(1);
+                await erc721Proxy.transferFrom.sendTransactionAsync(
                     encodedProxyMetadata,
                     makerAddress,
                     takerAddress,
                     amount,
                     { from: exchangeAddress },
-                ),
-            ).to.be.rejectedWith(constants.REVERT);
+                );
+                // Verify transfer was successful
+                const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(newOwnerMakerAsset).to.be.bignumber.equal(takerAddress);
+            });
+
+            it('should throw if transferring 0 amount of a token', async () => {
+                // Construct metadata for ERC721 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                );
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(0);
+                return expect(
+                    erc721Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        amount,
+                        { from: exchangeAddress },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
+
+            it('should throw if transferring > 1 amount of a token', async () => {
+                // Construct metadata for ERC721 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                );
+                // Verify pre-condition
+                const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
+                expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
+                // Perform a transfer from makerAddress to takerAddress
+                const erc20Balances = await erc20Wrapper.getBalancesAsync();
+                const amount = new BigNumber(500);
+                return expect(
+                    erc721Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        amount,
+                        { from: exchangeAddress },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
+
+            it('should throw if allowances are too low', async () => {
+                // Construct metadata for ERC721 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                );
+                // Remove transfer approval for makerAddress.
+                await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, false, {
+                    from: makerAddress,
+                });
+                // Perform a transfer; expect this to fail.
+                const amount = new BigNumber(1);
+                return expect(
+                    erc20Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        amount,
+                        {
+                            from: notAuthorized,
+                        },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
+
+            it('should throw if requesting address is not authorized', async () => {
+                // Construct metadata for ERC721 proxy
+                const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(
+                    erc721Token.address,
+                    erc721MakerTokenId,
+                );
+                // Perform a transfer from makerAddress to takerAddress
+                const amount = new BigNumber(1);
+                return expect(
+                    erc721Proxy.transferFrom.sendTransactionAsync(
+                        encodedProxyMetadata,
+                        makerAddress,
+                        takerAddress,
+                        amount,
+                        { from: notAuthorized },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
         });
 
-        it('should throw if transferring > 1 amount of a token', async () => {
-            // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(erc721Token.address, erc721MakerTokenId);
-            // Verify pre-condition
-            const ownerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
-            expect(ownerMakerAsset).to.be.bignumber.equal(makerAddress);
-            // Perform a transfer from makerAddress to takerAddress
-            const erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const amount = new BigNumber(500);
-            return expect(
-                erc721Proxy.transferFrom.sendTransactionAsync(
-                    encodedProxyMetadata,
-                    makerAddress,
-                    takerAddress,
-                    amount,
+        describe('batchTransferFrom', () => {
+            it('should succesfully make multiple token transfers', async () => {
+                const erc721TokensById = await erc721Wrapper.getBalancesAsync();
+                const [makerTokenIdA, makerTokenIdB] = erc721TokensById[makerAddress][erc721Token.address];
+
+                const numTransfers = 2;
+                const assetMetadata = [
+                    assetProxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenIdA),
+                    assetProxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenIdB),
+                ];
+                const fromAddresses = _.times(numTransfers, () => makerAddress);
+                const toAddresses = _.times(numTransfers, () => takerAddress);
+                const amounts = _.times(numTransfers, () => new BigNumber(1));
+
+                const txHash = await erc721Proxy.batchTransferFrom.sendTransactionAsync(
+                    assetMetadata,
+                    fromAddresses,
+                    toAddresses,
+                    amounts,
                     { from: exchangeAddress },
-                ),
-            ).to.be.rejectedWith(constants.REVERT);
-        });
+                );
+                const res = await zeroEx.awaitTransactionMinedAsync(txHash);
+                expect(res.logs.length).to.equal(numTransfers);
 
-        it('should throw if allowances are too low', async () => {
-            // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(erc721Token.address, erc721MakerTokenId);
-            // Remove transfer approval for makerAddress.
-            await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, false, {
-                from: makerAddress,
+                const newOwnerMakerAssetA = await erc721Token.ownerOf.callAsync(makerTokenIdA);
+                const newOwnerMakerAssetB = await erc721Token.ownerOf.callAsync(makerTokenIdB);
+                expect(newOwnerMakerAssetA).to.be.bignumber.equal(takerAddress);
+                expect(newOwnerMakerAssetB).to.be.bignumber.equal(takerAddress);
             });
-            // Perform a transfer; expect this to fail.
-            const amount = new BigNumber(1);
-            return expect(
-                erc20Proxy.transferFrom.sendTransactionAsync(encodedProxyMetadata, makerAddress, takerAddress, amount, {
-                    from: notAuthorized,
-                }),
-            ).to.be.rejectedWith(constants.REVERT);
-        });
 
-        it('should throw if requesting address is not authorized', async () => {
-            // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = assetProxyUtils.encodeERC721ProxyData(erc721Token.address, erc721MakerTokenId);
-            // Perform a transfer from makerAddress to takerAddress
-            const amount = new BigNumber(1);
-            return expect(
-                erc721Proxy.transferFrom.sendTransactionAsync(
-                    encodedProxyMetadata,
-                    makerAddress,
-                    takerAddress,
-                    amount,
-                    { from: notAuthorized },
-                ),
-            ).to.be.rejectedWith(constants.REVERT);
+            it('should throw if not called by an authorized address', async () => {
+                const erc721TokensById = await erc721Wrapper.getBalancesAsync();
+                const [makerTokenIdA, makerTokenIdB] = erc721TokensById[makerAddress][erc721Token.address];
+
+                const numTransfers = 2;
+                const assetMetadata = [
+                    assetProxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenIdA),
+                    assetProxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenIdB),
+                ];
+                const fromAddresses = _.times(numTransfers, () => makerAddress);
+                const toAddresses = _.times(numTransfers, () => takerAddress);
+                const amounts = _.times(numTransfers, () => new BigNumber(1));
+
+                expect(
+                    erc721Proxy.batchTransferFrom.sendTransactionAsync(
+                        assetMetadata,
+                        fromAddresses,
+                        toAddresses,
+                        amounts,
+                        { from: notAuthorized },
+                    ),
+                ).to.be.rejectedWith(constants.REVERT);
+            });
         });
 
         it('should have an id of 2', async () => {