Added ERC20BridgeProxy.transferFrom tests for DydxBridge

contracts/asset-proxy/test/dydx_bridge.ts

@@ -1,17 +1,38 @@
 import { blockchainTests, constants, expect, verifyEventsFromLogs } from '@0x/contracts-test-utils';
 import { AssetProxyId, RevertReason } from '@0x/types';
-import { AbiEncoder, BigNumber } from '@0x/utils';
+import { BigNumber } from '@0x/utils';
 import * as _ from 'lodash';
 
+import { DydxBridgeActionType, DydxBridgeData, dydxBridgeDataEncoder } from '../src/dydx_bridge_encoder';
+import { ERC20BridgeProxyContract, IAssetDataContract } from '../src/wrappers';
+
 import { artifacts } from './artifacts';
 import { TestDydxBridgeContract, TestDydxBridgeEvents } from './wrappers';
 
 blockchainTests.resets('DydxBridge unit tests', env => {
     const defaultAccountNumber = new BigNumber(1);
     const marketId = new BigNumber(2);
+    let tokenAddress: string;
     const defaultAmount = new BigNumber(4);
     const notAuthorized = '0x0000000000000000000000000000000000000001';
+    const defaultDepositAction = {
+        actionType: DydxBridgeActionType.Deposit as number,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
+    const defaultWithdrawAction = {
+        actionType: DydxBridgeActionType.Withdraw as number,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
     let testContract: TestDydxBridgeContract;
+    let testProxyContract: ERC20BridgeProxyContract;
+    let assetDataEncoder: IAssetDataContract;
+    let owner: string;
     let authorized: string;
     let accountOwner: string;
     let receiver: string;
@@ -19,7 +40,7 @@ blockchainTests.resets('DydxBridge unit tests', env => {
     before(async () => {
         // Get accounts
         const accounts = await env.web3Wrapper.getAvailableAddressesAsync();
-        [, /* owner */ authorized, accountOwner, receiver] = accounts;
+        [owner, authorized, accountOwner, receiver] = accounts;
 
         // Deploy dydx bridge
         testContract = await TestDydxBridgeContract.deployFrom0xArtifactAsync(
@@ -28,67 +49,37 @@ blockchainTests.resets('DydxBridge unit tests', env => {
             env.txDefaults,
             artifacts,
         );
+
+        // Deploy test erc20 bridge proxy
+        testProxyContract = await ERC20BridgeProxyContract.deployFrom0xArtifactAsync(
+            artifacts.ERC20BridgeProxy,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        await testProxyContract.addAuthorizedAddress(authorized).awaitTransactionSuccessAsync({ from: owner });
+
+        // Setup asset data encoder
+        assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
+        tokenAddress = testContract.address;
     });
 
     describe('bridgeTransferFrom()', () => {
-        enum BridgeActionType {
-            Deposit,
-            Withdraw,
-        }
-        interface BrigeAction {
-            actionType: BridgeActionType;
-            accountId: BigNumber;
-            marketId: BigNumber;
-            conversionRateNumerator: BigNumber;
-            conversionRateDenominator: BigNumber;
-        }
-        interface BridgeData {
-            accountNumbers: BigNumber[];
-            actions: BrigeAction[];
-        }
-        const defaultDepositAction = {
-            actionType: BridgeActionType.Deposit as number,
-            accountId: constants.ZERO_AMOUNT,
-            marketId,
-            conversionRateNumerator: constants.ZERO_AMOUNT,
-            conversionRateDenominator: constants.ZERO_AMOUNT,
-        };
-        const defaultWithdrawAction = {
-            actionType: BridgeActionType.Withdraw as number,
-            accountId: constants.ZERO_AMOUNT,
-            marketId,
-            conversionRateNumerator: constants.ZERO_AMOUNT,
-            conversionRateDenominator: constants.ZERO_AMOUNT,
-        };
-        const bridgeDataEncoder = AbiEncoder.create([
-            {
-                name: 'bridgeData',
-                type: 'tuple',
-                components: [
-                    { name: 'accountNumbers', type: 'uint256[]' },
-                    {
-                        name: 'actions',
-                        type: 'tuple[]',
-                        components: [
-                            { name: 'actionType', type: 'uint8' },
-                            { name: 'accountId', type: 'uint256' },
-                            { name: 'marketId', type: 'uint256' },
-                            { name: 'conversionRateNumerator', type: 'uint256' },
-                            { name: 'conversionRateDenominator', type: 'uint256' },
-                        ],
-                    },
-                ],
-            },
-        ]);
         const callBridgeTransferFrom = async (
             from: string,
             to: string,
             amount: BigNumber,
-            bridgeData: BridgeData,
+            bridgeData: DydxBridgeData,
             sender: string,
         ): Promise<string> => {
             const returnValue = await testContract
-                .bridgeTransferFrom(constants.NULL_ADDRESS, from, to, amount, bridgeDataEncoder.encode({ bridgeData }))
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
                 .callAsync({ from: sender });
             return returnValue;
         };
@@ -96,12 +87,18 @@ blockchainTests.resets('DydxBridge unit tests', env => {
             from: string,
             to: string,
             amount: BigNumber,
-            bridgeData: BridgeData,
+            bridgeData: DydxBridgeData,
             sender: string,
         ): Promise<void> => {
             // Execute transaction.
             const txReceipt = await testContract
-                .bridgeTransferFrom(constants.NULL_ADDRESS, from, to, amount, bridgeDataEncoder.encode({ bridgeData }))
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
                 .awaitTransactionSuccessAsync({ from: sender });
 
             // Verify `OperateAccount` event.
@@ -122,21 +119,50 @@ blockchainTests.resets('DydxBridge unit tests', env => {
                 expectedOperateActionEvents.push({
                     actionType: action.actionType as number,
                     accountId: action.accountId,
-                    amountSign: action.actionType === BridgeActionType.Deposit ? true : false,
+                    amountSign: action.actionType === DydxBridgeActionType.Deposit ? true : false,
                     amountDenomination: weiDenomination,
                     amountRef: deltaAmountRef,
                     amountValue: action.conversionRateDenominator.gt(0)
-                        ? amount.times(action.conversionRateNumerator).div(action.conversionRateDenominator)
+                        ? amount
+                              .times(action.conversionRateNumerator)
+                              .dividedToIntegerBy(action.conversionRateDenominator)
                         : amount,
                     primaryMarketId: marketId,
                     secondaryMarketId: constants.ZERO_AMOUNT,
-                    otherAddress: action.actionType === BridgeActionType.Deposit ? from : to,
+                    otherAddress: action.actionType === DydxBridgeActionType.Deposit ? from : to,
                     otherAccountId: constants.ZERO_AMOUNT,
                     data: '0x',
                 });
             }
             verifyEventsFromLogs(txReceipt.logs, expectedOperateActionEvents, TestDydxBridgeEvents.OperateAction);
         };
+        it('succeeds when calling with zero amount', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            await callBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                constants.ZERO_AMOUNT,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling with no accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [],
+                actions: [defaultDepositAction],
+            };
+            await callBridgeTransferFromAndVerifyEvents(accountOwner, receiver, defaultAmount, bridgeData, authorized);
+        });
+        it('succeeds when calling with no actions', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [],
+            };
+            await callBridgeTransferFromAndVerifyEvents(accountOwner, receiver, defaultAmount, bridgeData, authorized);
+        });
         it('succeeds when calling `operate` with the `deposit` action and a single account', async () => {
             const bridgeData = {
                 accountNumbers: [defaultAccountNumber],
@@ -151,7 +177,7 @@ blockchainTests.resets('DydxBridge unit tests', env => {
             };
             await callBridgeTransferFromAndVerifyEvents(accountOwner, receiver, defaultAmount, bridgeData, authorized);
         });
-        it('succeeds when calling `operate` with the `withdraw` action and a single accuont', async () => {
+        it('succeeds when calling `operate` with the `withdraw` action and a single account', async () => {
             const bridgeData = {
                 accountNumbers: [defaultAccountNumber],
                 actions: [defaultWithdrawAction],
@@ -240,5 +266,47 @@ blockchainTests.resets('DydxBridge unit tests', env => {
             );
             expect(returnValue).to.equal(AssetProxyId.ERC20Bridge);
         });
+        it('should revert when `Operate` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+
+            // Execute transfer.
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const tx = callBridgeTransferFrom(accountOwner, receiver, defaultAmount, bridgeData, authorized);
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+
+    describe('ERC20BridgeProxy.transferFrom()', () => {
+        const bridgeData = {
+            accountNumbers: [defaultAccountNumber],
+            actions: [defaultWithdrawAction],
+        };
+        let assetData: string;
+
+        before(async () => {
+            assetData = assetDataEncoder
+                .ERC20Bridge(tokenAddress, testContract.address, dydxBridgeDataEncoder.encode({ bridgeData }))
+                .getABIEncodedTransactionData();
+        });
+
+        it('should succeed if `bridgeTransferFrom` succeeds', async () => {
+            await testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+        });
+        it('should revert if `bridgeTransferFrom` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+            const tx = testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
     });
 });