Change tests

10 files changed, 275 insertions, 207 deletions

diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index 10816d2d6..5cedaddc9 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -13,6 +13,9 @@ import * as chai from 'chai';
 import ethUtil = require('ethereumjs-util');
 import * as Web3 from 'web3';
 
+import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
+import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
 import { Balances } from '../../util/balances';
 import { constants } from '../../util/constants';
 import { crypto } from '../../util/crypto';
@@ -37,11 +40,11 @@ describe('Exchange', () => {
     const INITIAL_BALANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
     const INITIAL_ALLOWANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
 
-    let rep: Web3.ContractInstance;
-    let dgd: Web3.ContractInstance;
-    let zrx: Web3.ContractInstance;
-    let exchange: Web3.ContractInstance;
-    let tokenTransferProxy: Web3.ContractInstance;
+    let rep: DummyTokenContract;
+    let dgd: DummyTokenContract;
+    let zrx: DummyTokenContract;
+    let exchange: ExchangeContract;
+    let tokenTransferProxy: TokenTransferProxyContract;
 
     let order: Order;
     let balances: BalancesByOwner;
@@ -55,14 +58,22 @@ describe('Exchange', () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         maker = accounts[0];
         [tokenOwner, taker, feeRecipient] = accounts;
-        [rep, dgd, zrx] = await Promise.all([
+        const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
             deployer.deployAsync(ContractName.DummyToken),
             deployer.deployAsync(ContractName.DummyToken),
             deployer.deployAsync(ContractName.DummyToken),
         ]);
-        tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
-        exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
-        await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
+        rep = new DummyTokenContract(repInstance);
+        dgd = new DummyTokenContract(dgdInstance);
+        zrx = new DummyTokenContract(zrxInstance);
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
+        const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
+            zrx.address,
+            tokenTransferProxy.address,
+        ]);
+        exchange = new ExchangeContract(exchangeInstance);
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
         zeroEx = new ZeroEx(web3.currentProvider, {
             exchangeContractAddress: exchange.address,
             networkId: constants.TESTRPC_NETWORK_ID,
@@ -83,30 +94,30 @@ describe('Exchange', () => {
         orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams);
         dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]);
         await Promise.all([
-            rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: maker,
             }),
-            rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: taker,
             }),
-            rep.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
-            rep.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
-            dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            rep.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
+            rep.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
+            dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: maker,
             }),
-            dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: taker,
             }),
-            dgd.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
-            dgd.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
-            zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            dgd.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
+            dgd.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
+            zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: maker,
             }),
-            zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: taker,
             }),
-            zrx.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }),
-            zrx.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }),
+            zrx.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }),
+            zrx.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }),
         ]);
     });
     beforeEach(async () => {
@@ -117,19 +128,19 @@ describe('Exchange', () => {
     });
     describe('internal functions', () => {
         it('should include transferViaTokenTransferProxy', () => {
-            expect(exchange.transferViaTokenTransferProxy).to.be.undefined();
+            expect((exchange as any).transferViaTokenTransferProxy).to.be.undefined();
         });
 
         it('should include isTransferable', () => {
-            expect(exchange.isTransferable).to.be.undefined();
+            expect((exchange as any).isTransferable).to.be.undefined();
         });
 
         it('should include getBalance', () => {
-            expect(exchange.getBalance).to.be.undefined();
+            expect((exchange as any).getBalance).to.be.undefined();
         });
 
         it('should include getAllowance', () => {
-            expect(exchange.getAllowance).to.be.undefined();
+            expect((exchange as any).getAllowance).to.be.undefined();
         });
     });
 
@@ -565,9 +576,9 @@ describe('Exchange', () => {
 
         it('should not change balances if maker allowances are too low to fill order and \
                 shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
-            await rep.approve(tokenTransferProxy.address, 0, { from: maker });
+            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker });
             await exWrapper.fillOrderAsync(order, taker);
-            await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: maker,
             });
 
@@ -577,22 +588,22 @@ describe('Exchange', () => {
 
         it('should throw if maker allowances are too low to fill order and \
                 shouldThrowOnInsufficientBalanceOrAllowance = true', async () => {
-            await rep.approve(tokenTransferProxy.address, 0, { from: maker });
+            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker });
             expect(
                 exWrapper.fillOrderAsync(order, taker, {
                     shouldThrowOnInsufficientBalanceOrAllowance: true,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
-            await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: maker,
             });
         });
 
         it('should not change balances if taker allowances are too low to fill order and \
                 shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
-            await dgd.approve(tokenTransferProxy.address, 0, { from: taker });
+            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker });
             await exWrapper.fillOrderAsync(order, taker);
-            await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: taker,
             });
 
@@ -602,13 +613,13 @@ describe('Exchange', () => {
 
         it('should throw if taker allowances are too low to fill order and \
                 shouldThrowOnInsufficientBalanceOrAllowance = true', async () => {
-            await dgd.approve(tokenTransferProxy.address, 0, { from: taker });
+            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker });
             expect(
                 exWrapper.fillOrderAsync(order, taker, {
                     shouldThrowOnInsufficientBalanceOrAllowance: true,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
-            await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+            await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
                 from: taker,
             });
         });
@@ -668,7 +679,9 @@ describe('Exchange', () => {
         it('should throw if getBalance or getAllowance attempts to change state and \
                 shouldThrowOnInsufficientBalanceOrAllowance = false', async () => {
             const maliciousToken = await deployer.deployAsync(ContractName.MaliciousToken);
-            await maliciousToken.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker });
+            await maliciousToken.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, {
+                from: taker,
+            });
 
             order = await orderFactory.newSignedOrderAsync({
                 takerToken: maliciousToken.address,
diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts
index 5efce41a4..33bf8b803 100644
--- a/packages/contracts/test/exchange/helpers.ts
+++ b/packages/contracts/test/exchange/helpers.ts
@@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import ethUtil = require('ethereumjs-util');
 
+import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange';
 import { constants } from '../../util/constants';
 import { ExchangeWrapper } from '../../util/exchange_wrapper';
 import { Order } from '../../util/order';
@@ -38,7 +39,11 @@ describe('Exchange', () => {
             deployer.deployAsync(ContractName.DummyToken),
             deployer.deployAsync(ContractName.DummyToken),
         ]);
-        const exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
+        const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
+            zrx.address,
+            tokenTransferProxy.address,
+        ]);
+        const exchange = new ExchangeContract(exchangeInstance);
         await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
         const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID });
         exchangeWrapper = new ExchangeWrapper(exchange, zeroEx);
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index acdf481a9..b1851a55c 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -6,6 +6,10 @@ import * as chai from 'chai';
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
+import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token';
+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 { Balances } from '../../util/balances';
 import { constants } from '../../util/constants';
 import { ExchangeWrapper } from '../../util/exchange_wrapper';
@@ -30,12 +34,12 @@ describe('Exchange', () => {
     const INIT_BAL = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
     const INIT_ALLOW = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18);
 
-    let rep: Web3.ContractInstance;
-    let dgd: Web3.ContractInstance;
-    let zrx: Web3.ContractInstance;
-    let exchange: Web3.ContractInstance;
-    let tokenRegistry: Web3.ContractInstance;
-    let tokenTransferProxy: Web3.ContractInstance;
+    let rep: DummyTokenContract;
+    let dgd: DummyTokenContract;
+    let zrx: DummyTokenContract;
+    let exchange: ExchangeContract;
+    let tokenRegistry: TokenRegistryContract;
+    let tokenTransferProxy: TokenTransferProxyContract;
 
     let balances: BalancesByOwner;
 
@@ -47,15 +51,24 @@ describe('Exchange', () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         tokenOwner = accounts[0];
         [maker, taker, feeRecipient] = accounts;
-        [rep, dgd, zrx] = await Promise.all([
+        const [repInstance, dgdInstance, zrxInstance] = await Promise.all([
             deployer.deployAsync(ContractName.DummyToken),
             deployer.deployAsync(ContractName.DummyToken),
             deployer.deployAsync(ContractName.DummyToken),
         ]);
-        tokenRegistry = await deployer.deployAsync(ContractName.TokenRegistry);
-        tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
-        exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]);
-        await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] });
+        rep = new DummyTokenContract(repInstance);
+        dgd = new DummyTokenContract(dgdInstance);
+        zrx = new DummyTokenContract(zrxInstance);
+        const tokenRegistryInstance = await deployer.deployAsync(ContractName.TokenRegistry);
+        tokenRegistry = new TokenRegistryContract(tokenRegistryInstance);
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
+        const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [
+            zrx.address,
+            tokenTransferProxy.address,
+        ]);
+        exchange = new ExchangeContract(exchangeInstance);
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] });
         const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID });
         exWrapper = new ExchangeWrapper(exchange, zeroEx);
 
@@ -74,18 +87,18 @@ describe('Exchange', () => {
         orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams);
         dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]);
         await Promise.all([
-            rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
-            rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
-            rep.setBalance(maker, INIT_BAL, { from: tokenOwner }),
-            rep.setBalance(taker, INIT_BAL, { from: tokenOwner }),
-            dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
-            dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
-            dgd.setBalance(maker, INIT_BAL, { from: tokenOwner }),
-            dgd.setBalance(taker, INIT_BAL, { from: tokenOwner }),
-            zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
-            zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
-            zrx.setBalance(maker, INIT_BAL, { from: tokenOwner }),
-            zrx.setBalance(taker, INIT_BAL, { from: tokenOwner }),
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
+            rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
+            rep.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
+            rep.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
+            dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
+            dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
+            dgd.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
+            dgd.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
+            zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }),
+            zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }),
+            zrx.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }),
+            zrx.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }),
         ]);
     });
     beforeEach(async () => {
diff --git a/packages/contracts/test/multi_sig_with_time_lock.ts b/packages/contracts/test/multi_sig_with_time_lock.ts
index bd64be1ba..6812cb09f 100644
--- a/packages/contracts/test/multi_sig_with_time_lock.ts
+++ b/packages/contracts/test/multi_sig_with_time_lock.ts
@@ -6,6 +6,8 @@ import * as chai from 'chai';
 import * as Web3 from 'web3';
 
 import * as multiSigWalletJSON from '../../build/contracts/MultiSigWalletWithTimeLock.json';
+import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet';
+import { MultiSigWalletWithTimeLockContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock';
 import { artifacts } from '../util/artifacts';
 import { constants } from '../util/constants';
 import { MultiSigWrapper } from '../util/multi_sig_wrapper';
@@ -30,12 +32,12 @@ describe('MultiSigWalletWithTimeLock', () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owners = [accounts[0], accounts[1]];
     });
-    const SIGNATURES_REQUIRED = 2;
-    const SECONDS_TIME_LOCKED = 10000;
+    const SIGNATURES_REQUIRED = new BigNumber(2);
+    const SECONDS_TIME_LOCKED = new BigNumber(10000);
 
-    let multiSig: Web3.ContractInstance;
+    let multiSig: MultiSigWalletWithTimeLockContract;
     let multiSigWrapper: MultiSigWrapper;
-    let txId: number;
+    let txId: BigNumber;
     let initialSecondsTimeLocked: number;
     let rpc: RPC;
 
@@ -52,20 +54,21 @@ describe('MultiSigWalletWithTimeLock', () => {
     describe('changeTimeLock', () => {
         describe('initially non-time-locked', async () => {
             before('deploy a walet', async () => {
-                multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
+                const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
                     owners,
                     SIGNATURES_REQUIRED,
                     0,
                 ]);
-                multiSigWrapper = new MultiSigWrapper(multiSig);
+                multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance);
+                multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
 
                 const secondsTimeLocked = await multiSig.secondsTimeLocked();
                 initialSecondsTimeLocked = secondsTimeLocked.toNumber();
             });
             it('should throw when not called by wallet', async () => {
-                return expect(multiSig.changeTimeLock(SECONDS_TIME_LOCKED, { from: owners[0] })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                return expect(
+                    multiSig.changeTimeLock.sendTransactionAsync(SECONDS_TIME_LOCKED, { from: owners[0] }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should throw without enough confirmations', async () => {
@@ -74,7 +77,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 const dataParams = {
                     name: 'changeTimeLock',
                     abi: MULTI_SIG_ABI,
-                    args: [SECONDS_TIME_LOCKED],
+                    args: [SECONDS_TIME_LOCKED.toNumber()],
                 };
                 const txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
                 const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@@ -82,10 +85,10 @@ describe('MultiSigWalletWithTimeLock', () => {
                     SubmissionContractEventArgs
                 >;
 
-                txId = log.args.transactionId.toNumber();
-                return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                txId = log.args.transactionId;
+                return expect(
+                    multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should set confirmation time with enough confirmations', async () => {
@@ -94,7 +97,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 const dataParams = {
                     name: 'changeTimeLock',
                     abi: MULTI_SIG_ABI,
-                    args: [SECONDS_TIME_LOCKED],
+                    args: [SECONDS_TIME_LOCKED.toNumber()],
                 };
                 let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
                 const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@@ -102,15 +105,15 @@ describe('MultiSigWalletWithTimeLock', () => {
                     SubmissionContractEventArgs
                 >;
 
-                txId = log.args.transactionId.toNumber();
-                txHash = await multiSig.confirmTransaction(txId, { from: owners[1] });
+                txId = log.args.transactionId;
+                txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
                 const res = await zeroEx.awaitTransactionMinedAsync(txHash);
                 expect(res.logs).to.have.length(2);
 
                 const blockNum = await web3Wrapper.getBlockNumberAsync();
                 const blockInfo = await web3Wrapper.getBlockAsync(blockNum);
                 const timestamp = new BigNumber(blockInfo.timestamp);
-                const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes.call(txId));
+                const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes(txId));
 
                 expect(timestamp).to.be.bignumber.equal(confirmationTimeBigNum);
             });
@@ -121,7 +124,7 @@ describe('MultiSigWalletWithTimeLock', () => {
                 const dataParams = {
                     name: 'changeTimeLock',
                     abi: MULTI_SIG_ABI,
-                    args: [SECONDS_TIME_LOCKED],
+                    args: [SECONDS_TIME_LOCKED.toNumber()],
                 };
                 let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams);
                 const subRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@@ -129,27 +132,28 @@ describe('MultiSigWalletWithTimeLock', () => {
                     SubmissionContractEventArgs
                 >;
 
-                txId = log.args.transactionId.toNumber();
-                txHash = await multiSig.confirmTransaction(txId, { from: owners[1] });
+                txId = log.args.transactionId;
+                txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
 
                 expect(initialSecondsTimeLocked).to.be.equal(0);
 
-                txHash = await multiSig.executeTransaction(txId, { from: owners[0] });
+                txHash = await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] });
                 const res = await zeroEx.awaitTransactionMinedAsync(txHash);
                 expect(res.logs).to.have.length(2);
 
-                const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call());
+                const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked());
                 expect(secondsTimeLocked).to.be.bignumber.equal(SECONDS_TIME_LOCKED);
             });
         });
         describe('initially time-locked', async () => {
             before('deploy a walet', async () => {
-                multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
+                const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [
                     owners,
                     SIGNATURES_REQUIRED,
                     SECONDS_TIME_LOCKED,
                 ]);
-                multiSigWrapper = new MultiSigWrapper(multiSig);
+                multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance);
+                multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
 
                 const secondsTimeLocked = await multiSig.secondsTimeLocked();
                 initialSecondsTimeLocked = secondsTimeLocked.toNumber();
@@ -165,8 +169,8 @@ describe('MultiSigWalletWithTimeLock', () => {
                 const log = abiDecoder.tryToDecodeLogOrNoop(subRes.logs[0]) as LogWithDecodedArgs<
                     SubmissionContractEventArgs
                 >;
-                txId = log.args.transactionId.toNumber();
-                txHash = await multiSig.confirmTransaction(txId, {
+                txId = log.args.transactionId;
+                txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, {
                     from: owners[1],
                 });
                 const confRes = await zeroEx.awaitTransactionMinedAsync(txHash);
@@ -174,16 +178,16 @@ describe('MultiSigWalletWithTimeLock', () => {
             });
             const newSecondsTimeLocked = 0;
             it('should throw if it has enough confirmations but is not past the time lock', async () => {
-                return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                return expect(
+                    multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should execute if it has enough confirmations and is past the time lock', async () => {
-                await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED);
-                await multiSig.executeTransaction(txId, { from: owners[0] });
+                await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED.toNumber());
+                await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] });
 
-                const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call());
+                const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked());
                 expect(secondsTimeLocked).to.be.bignumber.equal(newSecondsTimeLocked);
             });
         });
diff --git a/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts b/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts
index f6b7c1d53..7e9d44730 100644
--- a/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts
+++ b/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts
@@ -5,6 +5,9 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import * as Web3 from 'web3';
 
+import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet';
+import { MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock_except_remove_authorized_address';
+import { TokenTransferProxyContract } from '../src/contract_wrappers/generated/token_transfer_proxy';
 import { artifacts } from '../util/artifacts';
 import { constants } from '../util/constants';
 import { crypto } from '../util/crypto';
@@ -35,8 +38,8 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
     let authorizedAddress: string;
     let unauthorizedAddress: string;
 
-    let tokenTransferProxy: Web3.ContractInstance;
-    let multiSig: Web3.ContractInstance;
+    let tokenTransferProxy: TokenTransferProxyContract;
+    let multiSig: MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract;
     let multiSigWrapper: MultiSigWrapper;
 
     let validDestination: string;
@@ -45,20 +48,20 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
         owners = [accounts[0], accounts[1]];
         [authorizedAddress, unauthorizedAddress] = accounts;
         const initialOwner = accounts[0];
-        tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
-        await tokenTransferProxy.addAuthorizedAddress(authorizedAddress, {
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
+        await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(authorizedAddress, {
             from: initialOwner,
         });
-        multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress, [
-            owners,
-            requiredApprovals,
-            SECONDS_TIME_LOCKED,
-            tokenTransferProxy.address,
-        ]);
-        await tokenTransferProxy.transferOwnership(multiSig.address, {
+        const multiSigInstance = await deployer.deployAsync(
+            ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress,
+            [owners, requiredApprovals, SECONDS_TIME_LOCKED, tokenTransferProxy.address],
+        );
+        multiSig = new MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract(multiSigInstance);
+        await tokenTransferProxy.transferOwnership.sendTransactionAsync(multiSig.address, {
             from: initialOwner,
         });
-        multiSigWrapper = new MultiSigWrapper(multiSig);
+        multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract);
         validDestination = tokenTransferProxy.address;
     });
     beforeEach(async () => {
@@ -71,12 +74,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
     describe('isFunctionRemoveAuthorizedAddress', () => {
         it('should throw if data is not for removeAuthorizedAddress', async () => {
             const data = MultiSigWrapper.encodeFnArgs('addAuthorizedAddress', PROXY_ABI, [owners[0]]);
-            return expect(multiSig.isFunctionRemoveAuthorizedAddress.call(data)).to.be.rejectedWith(constants.REVERT);
+            return expect(multiSig.isFunctionRemoveAuthorizedAddress(data)).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should return true if data is for removeAuthorizedAddress', async () => {
             const data = MultiSigWrapper.encodeFnArgs('removeAuthorizedAddress', PROXY_ABI, [owners[0]]);
-            const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress.call(data);
+            const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress(data);
             expect(isFunctionRemoveAuthorizedAddress).to.be.true();
         });
     });
@@ -91,11 +94,11 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
             const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
             const res = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
-            const txId = log.args.transactionId.toString();
+            const txId = log.args.transactionId;
 
-            return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            return expect(
+                multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should throw if tx destination is not the tokenTransferProxy', async () => {
@@ -109,14 +112,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
             const txHash = await multiSigWrapper.submitTransactionAsync(invalidDestination, owners[0], dataParams);
             const res = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
-            const txId = log.args.transactionId.toString();
-            await multiSig.confirmTransaction(txId, { from: owners[1] });
-            const isConfirmed = await multiSig.isConfirmed.call(txId);
+            const txId = log.args.transactionId;
+            await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
+            const isConfirmed = await multiSig.isConfirmed(txId);
             expect(isConfirmed).to.be.true();
 
-            return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            return expect(
+                multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should throw if tx data is not for removeAuthorizedAddress', async () => {
@@ -128,14 +131,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
             const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
             const res = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
-            const txId = log.args.transactionId.toString();
-            await multiSig.confirmTransaction(txId, { from: owners[1] });
-            const isConfirmed = await multiSig.isConfirmed.call(txId);
+            const txId = log.args.transactionId;
+            await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
+            const isConfirmed = await multiSig.isConfirmed(txId);
             expect(isConfirmed).to.be.true();
 
-            return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            return expect(
+                multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should execute removeAuthorizedAddress for valid tokenTransferProxy if fully confirmed', async () => {
@@ -147,12 +150,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
             const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
             const res = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
-            const txId = log.args.transactionId.toString();
-            await multiSig.confirmTransaction(txId, { from: owners[1] });
-            const isConfirmed = await multiSig.isConfirmed.call(txId);
+            const txId = log.args.transactionId;
+            await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
+            const isConfirmed = await multiSig.isConfirmed(txId);
             expect(isConfirmed).to.be.true();
-            await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] });
-            const isAuthorized = await tokenTransferProxy.authorized.call(authorizedAddress);
+            await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] });
+            const isAuthorized = await tokenTransferProxy.authorized(authorizedAddress);
             expect(isAuthorized).to.be.false();
         });
 
@@ -165,17 +168,17 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => {
             const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams);
             const res = await zeroEx.awaitTransactionMinedAsync(txHash);
             const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs<SubmissionContractEventArgs>;
-            const txId = log.args.transactionId.toString();
-            await multiSig.confirmTransaction(txId, { from: owners[1] });
+            const txId = log.args.transactionId;
+            await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] });
             const isConfirmed = await multiSig.isConfirmed(txId);
             expect(isConfirmed).to.be.true();
-            await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] });
+            await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] });
             const tx = await multiSig.transactions(txId);
             const isExecuted = tx[3];
             expect(isExecuted).to.be.true();
-            return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            return expect(
+                multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
     });
 });
diff --git a/packages/contracts/test/token_registry.ts b/packages/contracts/test/token_registry.ts
index 2a270dc2f..867282d2c 100644
--- a/packages/contracts/test/token_registry.ts
+++ b/packages/contracts/test/token_registry.ts
@@ -1,11 +1,13 @@
 import { 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 { TokenRegistryContract } from '../src/contract_wrappers/generated/token_registry';
 import { constants } from '../util/constants';
 import { TokenRegWrapper } from '../util/token_registry_wrapper';
 import { ContractName } from '../util/types';
@@ -22,13 +24,14 @@ const blockchainLifecycle = new BlockchainLifecycle();
 describe('TokenRegistry', () => {
     let owner: string;
     let notOwner: string;
-    let tokenReg: Web3.ContractInstance;
+    let tokenReg: TokenRegistryContract;
     let tokenRegWrapper: TokenRegWrapper;
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owner = accounts[0];
         notOwner = accounts[1];
-        tokenReg = await deployer.deployAsync(ContractName.TokenRegistry);
+        const tokenRegInstance = await deployer.deployAsync(ContractName.TokenRegistry);
+        tokenReg = new TokenRegistryContract(tokenRegInstance);
         tokenRegWrapper = new TokenRegWrapper(tokenReg);
     });
     beforeEach(async () => {
@@ -132,12 +135,12 @@ describe('TokenRegistry', () => {
         describe('setTokenName', () => {
             it('should throw when not called by owner', async () => {
                 return expect(
-                    tokenReg.setTokenName(token1.address, token2.name, { from: notOwner }),
+                    tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: notOwner }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should change the token name when called by owner', async () => {
-                await tokenReg.setTokenName(token1.address, token2.name, {
+                await tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, {
                     from: owner,
                 });
                 const [newData, oldData] = await Promise.all([
@@ -154,14 +157,14 @@ describe('TokenRegistry', () => {
             it('should throw if the name already exists', async () => {
                 await tokenRegWrapper.addTokenAsync(token2, owner);
 
-                return expect(tokenReg.setTokenName(token1.address, token2.name, { from: owner })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                return expect(
+                    tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: owner }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should throw if token does not exist', async () => {
                 return expect(
-                    tokenReg.setTokenName(nullToken.address, token2.name, { from: owner }),
+                    tokenReg.setTokenName.sendTransactionAsync(nullToken.address, token2.name, { from: owner }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
         });
@@ -169,14 +172,14 @@ describe('TokenRegistry', () => {
         describe('setTokenSymbol', () => {
             it('should throw when not called by owner', async () => {
                 return expect(
-                    tokenReg.setTokenSymbol(token1.address, token2.symbol, {
+                    tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, {
                         from: notOwner,
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should change the token symbol when called by owner', async () => {
-                await tokenReg.setTokenSymbol(token1.address, token2.symbol, { from: owner });
+                await tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, { from: owner });
                 const [newData, oldData] = await Promise.all([
                     tokenRegWrapper.getTokenBySymbolAsync(token2.symbol),
                     tokenRegWrapper.getTokenBySymbolAsync(token1.symbol),
@@ -192,7 +195,7 @@ describe('TokenRegistry', () => {
                 await tokenRegWrapper.addTokenAsync(token2, owner);
 
                 return expect(
-                    tokenReg.setTokenSymbol(token1.address, token2.symbol, {
+                    tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, {
                         from: owner,
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
@@ -200,7 +203,7 @@ describe('TokenRegistry', () => {
 
             it('should throw if token does not exist', async () => {
                 return expect(
-                    tokenReg.setTokenSymbol(nullToken.address, token2.symbol, {
+                    tokenReg.setTokenSymbol.sendTransactionAsync(nullToken.address, token2.symbol, {
                         from: owner,
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
@@ -209,15 +212,15 @@ describe('TokenRegistry', () => {
 
         describe('removeToken', () => {
             it('should throw if not called by owner', async () => {
-                const index = 0;
-                return expect(tokenReg.removeToken(token1.address, index, { from: notOwner })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                const index = new BigNumber(0);
+                return expect(
+                    tokenReg.removeToken.sendTransactionAsync(token1.address, index, { from: notOwner }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should remove token metadata when called by owner', async () => {
-                const index = 0;
-                await tokenReg.removeToken(token1.address, index, {
+                const index = new BigNumber(0);
+                await tokenReg.removeToken.sendTransactionAsync(token1.address, index, {
                     from: owner,
                 });
                 const tokenData = await tokenRegWrapper.getTokenMetaDataAsync(token1.address);
@@ -225,18 +228,18 @@ describe('TokenRegistry', () => {
             });
 
             it('should throw if token does not exist', async () => {
-                const index = 0;
-                return expect(tokenReg.removeToken(nullToken.address, index, { from: owner })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                const index = new BigNumber(0);
+                return expect(
+                    tokenReg.removeToken.sendTransactionAsync(nullToken.address, index, { from: owner }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
 
             it('should throw if token at given index does not match address', async () => {
                 await tokenRegWrapper.addTokenAsync(token2, owner);
-                const incorrectIndex = 0;
-                return expect(tokenReg.removeToken(token2.address, incorrectIndex, { from: owner })).to.be.rejectedWith(
-                    constants.REVERT,
-                );
+                const incorrectIndex = new BigNumber(0);
+                return expect(
+                    tokenReg.removeToken.sendTransactionAsync(token2.address, incorrectIndex, { from: owner }),
+                ).to.be.rejectedWith(constants.REVERT);
             });
         });
     });
diff --git a/packages/contracts/test/token_transfer_proxy/auth.ts b/packages/contracts/test/token_transfer_proxy/auth.ts
index b2bfc6b65..9d453b079 100644
--- a/packages/contracts/test/token_transfer_proxy/auth.ts
+++ b/packages/contracts/test/token_transfer_proxy/auth.ts
@@ -3,6 +3,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import * as Web3 from 'web3';
 
+import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy';
 import { constants } from '../../util/constants';
 import { ContractName } from '../../util/types';
 import { chaiSetup } from '../utils/chai_setup';
@@ -18,12 +19,13 @@ describe('TokenTransferProxy', () => {
     let owner: string;
     let notOwner: string;
     let address: string;
-    let tokenTransferProxy: Web3.ContractInstance;
+    let tokenTransferProxy: TokenTransferProxyContract;
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owner = address = accounts[0];
         notOwner = accounts[1];
-        tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy);
+        tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance);
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -33,36 +35,36 @@ describe('TokenTransferProxy', () => {
     });
     describe('addAuthorizedAddress', () => {
         it('should throw if not called by owner', async () => {
-            return expect(tokenTransferProxy.addAuthorizedAddress(notOwner, { from: notOwner })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            return expect(
+                tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notOwner, { from: notOwner }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
         it('should allow owner to add an authorized address', async () => {
-            await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
             const isAuthorized = await tokenTransferProxy.authorized(address);
             expect(isAuthorized).to.be.true();
         });
         it('should throw if owner attempts to authorize a duplicate address', async () => {
-            await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
-            return expect(tokenTransferProxy.addAuthorizedAddress(address, { from: owner })).to.be.rejectedWith(
-                constants.REVERT,
-            );
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
+            return expect(
+                tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            ).to.be.rejectedWith(constants.REVERT);
         });
     });
 
     describe('removeAuthorizedAddress', () => {
         it('should throw if not called by owner', async () => {
-            await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
             return expect(
-                tokenTransferProxy.removeAuthorizedAddress(address, {
+                tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
                     from: notOwner,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should allow owner to remove an authorized address', async () => {
-            await tokenTransferProxy.addAuthorizedAddress(address, { from: owner });
-            await tokenTransferProxy.removeAuthorizedAddress(address, {
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner });
+            await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
                 from: owner,
             });
             const isAuthorized = await tokenTransferProxy.authorized(address);
@@ -71,7 +73,7 @@ describe('TokenTransferProxy', () => {
 
         it('should throw if owner attempts to remove an address that is not authorized', async () => {
             return expect(
-                tokenTransferProxy.removeAuthorizedAddress(address, {
+                tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
                     from: owner,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
@@ -82,14 +84,14 @@ describe('TokenTransferProxy', () => {
         it('should return all authorized addresses', async () => {
             const initial = await tokenTransferProxy.getAuthorizedAddresses();
             expect(initial).to.have.length(0);
-            await tokenTransferProxy.addAuthorizedAddress(address, {
+            await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, {
                 from: owner,
             });
             const afterAdd = await tokenTransferProxy.getAuthorizedAddresses();
             expect(afterAdd).to.have.length(1);
             expect(afterAdd).to.include(address);
 
-            await tokenTransferProxy.removeAuthorizedAddress(address, {
+            await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, {
                 from: owner,
             });
             const afterRemove = await tokenTransferProxy.getAuthorizedAddresses();
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(
diff --git a/packages/contracts/test/unlimited_allowance_token.ts b/packages/contracts/test/unlimited_allowance_token.ts
index 34d2ba33b..f0a66e76b 100644
--- a/packages/contracts/test/unlimited_allowance_token.ts
+++ b/packages/contracts/test/unlimited_allowance_token.ts
@@ -5,6 +5,7 @@ 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 { constants } from '../util/constants';
 import { ContractName } from '../util/types';
 
@@ -27,14 +28,15 @@ describe('UnlimitedAllowanceToken', () => {
 
     const MAX_MINT_VALUE = new BigNumber(100000000000000000000);
     let tokenAddress: string;
-    let token: Web3.ContractInstance;
+    let token: DummyTokenContract;
 
     before(async () => {
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         owner = accounts[0];
         spender = accounts[1];
-        token = await deployer.deployAsync(ContractName.DummyToken);
-        await token.mint(MAX_MINT_VALUE, { from: owner });
+        const tokenInstance = await deployer.deployAsync(ContractName.DummyToken);
+        token = new DummyTokenContract(tokenInstance);
+        await token.mint.sendTransactionAsync(MAX_MINT_VALUE, { from: owner });
         tokenAddress = token.address;
     });
     beforeEach(async () => {
@@ -47,7 +49,7 @@ describe('UnlimitedAllowanceToken', () => {
         it('should throw if owner has insufficient balance', async () => {
             const ownerBalance = await zeroEx.token.getBalanceAsync(tokenAddress, owner);
             const amountToTransfer = ownerBalance.plus(1);
-            return expect(token.transfer.call(spender, amountToTransfer, { from: owner })).to.be.rejectedWith(
+            return expect(token.transfer.callAsync(spender, amountToTransfer, { from: owner })).to.be.rejectedWith(
                 constants.REVERT,
             );
         });
@@ -67,7 +69,7 @@ describe('UnlimitedAllowanceToken', () => {
         });
 
         it('should return true on a 0 value transfer', async () => {
-            const didReturnTrue = await token.transfer.call(spender, 0, {
+            const didReturnTrue = await token.transfer.callAsync(spender, new BigNumber(0), {
                 from: owner,
             });
             expect(didReturnTrue).to.be.true();
@@ -80,7 +82,7 @@ describe('UnlimitedAllowanceToken', () => {
             const amountToTransfer = ownerBalance.plus(1);
             await zeroEx.token.setAllowanceAsync(tokenAddress, owner, spender, amountToTransfer);
             return expect(
-                token.transferFrom.call(owner, spender, amountToTransfer, {
+                token.transferFrom.callAsync(owner, spender, amountToTransfer, {
                     from: spender,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
@@ -95,15 +97,17 @@ describe('UnlimitedAllowanceToken', () => {
             expect(spenderAllowanceIsInsufficient).to.be.true();
 
             return expect(
-                token.transferFrom.call(owner, spender, amountToTransfer, {
+                token.transferFrom.callAsync(owner, spender, amountToTransfer, {
                     from: spender,
                 }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should return true on a 0 value transfer', async () => {
-            const amountToTransfer = 0;
-            const didReturnTrue = await token.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
+            const amountToTransfer = new BigNumber(0);
+            const didReturnTrue = await token.transferFrom.callAsync(owner, spender, amountToTransfer, {
+                from: spender,
+            });
             expect(didReturnTrue).to.be.true();
         });
 
diff --git a/packages/contracts/test/zrx_token.ts b/packages/contracts/test/zrx_token.ts
index 1844a67af..5e4bfed37 100644
--- a/packages/contracts/test/zrx_token.ts
+++ b/packages/contracts/test/zrx_token.ts
@@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import * as chai from 'chai';
 import * as Web3 from 'web3';
 
+import { ZRXTokenContract } from '../src/contract_wrappers/generated/z_r_x_token';
 import { constants } from '../util/constants';
 import { ContractName } from '../util/types';
 
@@ -24,7 +25,7 @@ describe('ZRXToken', () => {
 
     let MAX_UINT: BigNumber;
 
-    let zrx: Web3.ContractInstance;
+    let zrx: ZRXTokenContract;
     let zrxAddress: string;
 
     before(async () => {
@@ -34,7 +35,8 @@ describe('ZRXToken', () => {
         zeroEx = new ZeroEx(web3.currentProvider, {
             networkId: constants.TESTRPC_NETWORK_ID,
         });
-        zrx = await deployer.deployAsync(ContractName.ZRXToken);
+        const zrxInstance = await deployer.deployAsync(ContractName.ZRXToken);
+        zrx = new ZRXTokenContract(zrxInstance);
         zrxAddress = zrx.address;
         MAX_UINT = zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
     });
@@ -94,7 +96,7 @@ describe('ZRXToken', () => {
         });
 
         it('should return true on a 0 value transfer', async () => {
-            const didReturnTrue = await zrx.transfer.call(spender, 0, {
+            const didReturnTrue = await zrx.transfer.callAsync(spender, new BigNumber(0), {
                 from: owner,
             });
             expect(didReturnTrue).to.be.true();
@@ -108,7 +110,7 @@ describe('ZRXToken', () => {
             await zeroEx.token.setAllowanceAsync(zrxAddress, owner, spender, amountToTransfer, {
                 gasLimit: constants.MAX_TOKEN_APPROVE_GAS,
             });
-            const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
+            const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
             expect(didReturnTrue).to.be.false();
         });
 
@@ -120,13 +122,13 @@ describe('ZRXToken', () => {
             const spenderAllowanceIsInsufficient = spenderAllowance.cmp(amountToTransfer) < 0;
             expect(spenderAllowanceIsInsufficient).to.be.true();
 
-            const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
+            const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
             expect(didReturnTrue).to.be.false();
         });
 
         it('should return true on a 0 value transfer', async () => {
-            const amountToTransfer = 0;
-            const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender });
+            const amountToTransfer = new BigNumber(0);
+            const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender });
             expect(didReturnTrue).to.be.true();
         });