From 218876ac196a1b1bf7eba096a7bc6a2b3b8556bf Mon Sep 17 00:00:00 2001 From: Amir Bandeali Date: Mon, 5 Feb 2018 16:25:52 -0800 Subject: Fix artifacts path --- packages/contracts/test/utils/deployer.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/contracts/test') diff --git a/packages/contracts/test/utils/deployer.ts b/packages/contracts/test/utils/deployer.ts index dc41e41e2..4e7f35c72 100644 --- a/packages/contracts/test/utils/deployer.ts +++ b/packages/contracts/test/utils/deployer.ts @@ -5,7 +5,7 @@ import * as path from 'path'; import { constants } from '../../util/constants'; const deployerOpts = { - artifactsDir: path.resolve('artifacts'), + artifactsDir: path.resolve('src', 'artifacts'), jsonrpcPort: devConstants.RPC_PORT, networkId: constants.TESTRPC_NETWORK_ID, defaults: { -- cgit v1.2.3 From a264c36a48d224a55c2ef883f207692752ca74c7 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:40:03 +0100 Subject: Change tests --- packages/contracts/test/exchange/core.ts | 81 ++++++++++++--------- packages/contracts/test/exchange/helpers.ts | 7 +- packages/contracts/test/exchange/wrapper.ts | 59 +++++++++------ .../contracts/test/multi_sig_with_time_lock.ts | 70 +++++++++--------- ...i_sig_with_time_lock_except_remove_auth_addr.ts | 85 +++++++++++----------- packages/contracts/test/token_registry.ts | 55 +++++++------- .../contracts/test/token_transfer_proxy/auth.ts | 36 ++++----- .../test/token_transfer_proxy/transfer_from.ts | 51 +++++++++---- .../contracts/test/unlimited_allowance_token.ts | 22 +++--- packages/contracts/test/zrx_token.ts | 16 ++-- 10 files changed, 275 insertions(+), 207 deletions(-) (limited to 'packages/contracts/test') 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; - 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; - 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; - 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; - 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; - 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(); }); -- cgit v1.2.3 From b61852b1f5501efd357e61c5478f25b68455dc38 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 22:40:14 +0100 Subject: Special-case ZRXToken snake case conversion --- packages/contracts/test/zrx_token.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/contracts/test') diff --git a/packages/contracts/test/zrx_token.ts b/packages/contracts/test/zrx_token.ts index 5e4bfed37..1610ada12 100644 --- a/packages/contracts/test/zrx_token.ts +++ b/packages/contracts/test/zrx_token.ts @@ -5,7 +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 { ZRXTokenContract } from '../src/contract_wrappers/generated/zrx_token'; import { constants } from '../util/constants'; import { ContractName } from '../util/types'; -- cgit v1.2.3