Change tests

1 files changed, 35 insertions, 16 deletions

diff --git a/packages/contracts/test/token_transfer_proxy/transfer_from.ts b/packages/contracts/test/token_transfer_proxy/transfer_from.ts
index bd7adcfae..c35a7276a 100644
--- a/packages/contracts/test/token_transfer_proxy/transfer_from.ts
+++ b/packages/contracts/test/token_transfer_proxy/transfer_from.ts
@@ -1,8 +1,11 @@
 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 { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
 import { Balances } from '../../util/balances';
 import { constants } from '../../util/constants';
 import { ContractName } from '../../util/types';
@@ -19,29 +22,31 @@ describe('TokenTransferProxy', () => {
     let accounts: string[];
     let owner: string;
     let notAuthorized: string;
-    const INIT_BAL = 100000000;
-    const INIT_ALLOW = 100000000;
+    const INIT_BAL = new BigNumber(100000000);
+    const INIT_ALLOW = new BigNumber(100000000);
 
-    let tokenTransferProxy: Web3.ContractInstance;
-    let rep: Web3.ContractInstance;
+    let tokenTransferProxy: TokenTransferProxyContract;
+    let rep: DummyTokenContract;
     let dmyBalances: Balances;
 
     before(async () => {
         accounts = await web3Wrapper.getAvailableAddressesAsync();
         owner = notAuthorized = accounts[0];
-        tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
-        rep = await deployer.deployAsync(ContractName.DummyToken);
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
+        const repInstance = await deployer.deployAsync(ContractName.DummyToken);
+        rep = new DummyTokenContract(repInstance);
 
         dmyBalances = new Balances([rep], [accounts[0], accounts[1]]);
         await Promise.all([
-            rep.approve(tokenTransferProxy.address, INIT_ALLOW, {
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, {
                 from: accounts[0],
             }),
-            rep.setBalance(accounts[0], INIT_BAL, { from: owner }),
-            rep.approve(tokenTransferProxy.address, INIT_ALLOW, {
+            rep.setBalance.sendTransactionAsync(accounts[0], INIT_BAL, { from: owner }),
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, {
                 from: accounts[1],
             }),
-            rep.setBalance(accounts[1], INIT_BAL, { from: owner }),
+            rep.setBalance.sendTransactionAsync(accounts[1], INIT_BAL, { from: owner }),
         ]);
     });
     beforeEach(async () => {
@@ -54,20 +59,34 @@ describe('TokenTransferProxy', () => {
     describe('transferFrom', () => {
         it('should throw when called by an unauthorized address', async () => {
             expect(
-                tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], 1000, { from: notAuthorized }),
+                tokenTransferProxy.transferFrom.sendTransactionAsync(
+                    rep.address,
+                    accounts[0],
+                    accounts[1],
+                    new BigNumber(1000),
+                    {
+                        from: notAuthorized,
+                    },
+                ),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should allow an authorized address to transfer', async () => {
             const balances = await dmyBalances.getAsync();
 
-            await tokenTransferProxy.addAuthorizedAddress(notAuthorized, {
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notAuthorized, {
                 from: owner,
             });
-            const transferAmt = 10000;
-            await tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], transferAmt, {
-                from: notAuthorized,
-            });
+            const transferAmt = new BigNumber(10000);
+            await tokenTransferProxy.transferFrom.sendTransactionAsync(
+                rep.address,
+                accounts[0],
+                accounts[1],
+                transferAmt,
+                {
+                    from: notAuthorized,
+                },
+            );
 
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances[accounts[0]][rep.address]).to.be.bignumber.equal(