Make wrappers small again (#2243)

* introduce --debug option to abi-gen and remove debug functions from @0x/abi-gen-wrappers * make evmExecAsync protected; ignore deployedBytecode in doc comment * trim deployedBytecode so it's undefined unless a contract has pure functions * remove validateAndSendTransactionAsync * Create `AwaitTransactionSuccessOpts` and `SendTransactionOpts` types * Remove duplicate types `IndexedFilterValues`, `DecodedLogEvent`, `EventCallback` from `@0x/base-contract`
2019-10-16 09:38:34 -07:00
parent 23198174f3
commit 0e90b0e7d0
70 changed files with 1834 additions and 12279 deletions
--- a/contracts/asset-proxy/package.json
+++ b/contracts/asset-proxy/package.json
@@ -22,7 +22,7 @@
        "compile": "sol-compiler",
        "watch": "sol-compiler -w",
        "clean": "shx rm -rf lib generated-artifacts generated-wrappers",
-        "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --output generated-wrappers --backend ethers",
+        "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output generated-wrappers --backend ethers",
        "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
        "coverage:report:text": "istanbul report text",
--- a/contracts/asset-proxy/test/authorizable.ts
+++ b/contracts/asset-proxy/test/authorizable.ts
@@ -1,11 +1,4 @@
-import {
-    chaiSetup,
-    constants,
-    expectTransactionFailedAsync,
-    provider,
-    txDefaults,
-    web3Wrapper,
-} from '@0x/contracts-test-utils';
+import { chaiSetup, expectTransactionFailedAsync, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { RevertReason } from '@0x/types';
 import { BigNumber } from '@0x/utils';
@@ -60,21 +53,13 @@ describe('Authorizable', () => {
        });

        it('should allow owner to add an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const isAuthorized = await authorizable.authorized.callAsync(address);
            expect(isAuthorized).to.be.true();
        });

        it('should revert if owner attempts to authorize a duplicate address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            return expectTransactionFailedAsync(
                authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
                RevertReason.TargetAlreadyAuthorized,
@@ -84,11 +69,7 @@ describe('Authorizable', () => {

    describe('removeAuthorizedAddress', () => {
        it('should revert if not called by owner', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            await expectTransactionFailedAsync(
                authorizable.removeAuthorizedAddress.sendTransactionAsync(address, { from: notOwner }),
                RevertReason.OnlyContractOwner,
@@ -96,16 +77,8 @@ describe('Authorizable', () => {
        });

        it('should allow owner to remove an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const isAuthorized = await authorizable.authorized.callAsync(address);
            expect(isAuthorized).to.be.false();
        });
@@ -122,11 +95,7 @@ describe('Authorizable', () => {

    describe('removeAuthorizedAddressAtIndex', () => {
        it('should revert if not called by owner', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const index = new BigNumber(0);
            await expectTransactionFailedAsync(
                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
@@ -137,11 +106,7 @@ describe('Authorizable', () => {
        });

        it('should revert if index is >= authorities.length', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const index = new BigNumber(1);
            return expectTransactionFailedAsync(
                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
@@ -164,16 +129,8 @@ describe('Authorizable', () => {
        it('should revert if address at index does not match target', async () => {
            const address1 = address;
            const address2 = notOwner;
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address1,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address2,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address1, { from: owner });
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address2, { from: owner });
            const address1Index = new BigNumber(0);
            return expectTransactionFailedAsync(
                authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address2, address1Index, {
@@ -184,18 +141,11 @@ describe('Authorizable', () => {
        });

        it('should allow owner to remove an authorized address', async () => {
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const index = new BigNumber(0);
-            await authorizable.removeAuthorizedAddressAtIndex.awaitTransactionSuccessAsync(
-                address,
-                index,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.removeAuthorizedAddressAtIndex.awaitTransactionSuccessAsync(address, index, {
+                from: owner,
+            });
            const isAuthorized = await authorizable.authorized.callAsync(address);
            expect(isAuthorized).to.be.false();
        });
@@ -205,19 +155,11 @@ describe('Authorizable', () => {
        it('should return all authorized addresses', async () => {
            const initial = await authorizable.getAuthorizedAddresses.callAsync();
            expect(initial).to.have.length(0);
-            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const afterAdd = await authorizable.getAuthorizedAddresses.callAsync();
            expect(afterAdd).to.have.length(1);
            expect(afterAdd).to.include(address);
-            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
-                address,
-                { from: owner },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(address, { from: owner });
            const afterRemove = await authorizable.getAuthorizedAddresses.callAsync();
            expect(afterRemove).to.have.length(0);
        });
--- a/contracts/asset-proxy/test/erc1155_proxy.ts
+++ b/contracts/asset-proxy/test/erc1155_proxy.ts
@@ -72,16 +72,8 @@ describe('ERC1155Proxy', () => {
        const usedAddresses = ([owner, notAuthorized, authorized, spender, receiver] = _.slice(accounts, 0, 5));
        erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
        erc1155Proxy = await erc1155ProxyWrapper.deployProxyAsync();
-        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            authorized,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            erc1155Proxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(authorized, { from: owner });
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(erc1155Proxy.address, { from: owner });
        // deploy & configure ERC1155 tokens and receiver
        [erc1155Wrapper] = await erc1155ProxyWrapper.deployDummyContractsAsync();
        erc1155Contract = erc1155Wrapper.getContract();
@@ -696,25 +688,18 @@ describe('ERC1155Proxy', () => {
            const tokenUri = '';
            for (const tokenToCreate of tokensToCreate) {
                // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType.awaitTransactionSuccessAsync(tokenToCreate, tokenUri, {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });

                // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible.awaitTransactionSuccessAsync(tokenToCreate, [spender], [spenderInitialBalance], {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
            }
            ///// Step 2/5 /////
            // Check balances before transfer
@@ -805,25 +790,18 @@ describe('ERC1155Proxy', () => {
            const tokenUri = '';
            for (const tokenToCreate of tokensToCreate) {
                // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType.awaitTransactionSuccessAsync(tokenToCreate, tokenUri, {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });

                // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible.awaitTransactionSuccessAsync(tokenToCreate, [spender], [spenderInitialBalance], {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
            }
            ///// Step 2/5 /////
            // Check balances before transfer
@@ -937,25 +915,18 @@ describe('ERC1155Proxy', () => {
            const tokenUri = '';
            for (const tokenToCreate of tokensToCreate) {
                // create token
-                await erc1155Wrapper.getContract().createWithType.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    tokenUri,
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .createWithType.awaitTransactionSuccessAsync(tokenToCreate, tokenUri, {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });

                // mint balance for spender
-                await erc1155Wrapper.getContract().mintFungible.awaitTransactionSuccessAsync(
-                    tokenToCreate,
-                    [spender],
-                    [spenderInitialBalance],
-                    {
+                await erc1155Wrapper
+                    .getContract()
+                    .mintFungible.awaitTransactionSuccessAsync(tokenToCreate, [spender], [spenderInitialBalance], {
                        from: owner,
-                    },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                    });
            }
            ///// Step 2/5 /////
            // Check balances before transfer
@@ -1667,13 +1638,9 @@ describe('ERC1155Proxy', () => {
        it('should propagate revert reason from erc1155 contract failure', async () => {
            // disable transfers
            const shouldRejectTransfer = true;
-            await erc1155Receiver.setRejectTransferFlag.awaitTransactionSuccessAsync(
-                shouldRejectTransfer,
-                {
-                    from: owner,
-                },
-                constants.AWAIT_TRANSACTION_MINED_MS,
-            );
+            await erc1155Receiver.setRejectTransferFlag.awaitTransactionSuccessAsync(shouldRejectTransfer, {
+                from: owner,
+            });
            // setup test parameters
            const tokenHolders = [spender, receiverContract];
            const tokensToTransfer = fungibleTokens.slice(0, 1);
--- a/contracts/asset-proxy/test/proxies.ts
+++ b/contracts/asset-proxy/test/proxies.ts
@@ -105,64 +105,24 @@ describe('Asset Transfer Proxies', () => {
        );

        // Configure ERC20Proxy
-        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            authorized,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            multiAssetProxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(authorized, { from: owner });
+        await erc20Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(multiAssetProxy.address, { from: owner });

        // Configure ERC721Proxy
-        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            authorized,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            multiAssetProxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(authorized, { from: owner });
+        await erc721Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(multiAssetProxy.address, { from: owner });

        // Configure ERC115Proxy
        erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
        erc1155Proxy = await erc1155ProxyWrapper.deployProxyAsync();
-        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            authorized,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            multiAssetProxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(authorized, { from: owner });
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(multiAssetProxy.address, { from: owner });

        // Configure MultiAssetProxy
-        await multiAssetProxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
-            authorized,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
-            erc20Proxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
-            erc721Proxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
-        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(
-            erc1155Proxy.address,
-            { from: owner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await multiAssetProxy.addAuthorizedAddress.awaitTransactionSuccessAsync(authorized, { from: owner });
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(erc20Proxy.address, { from: owner });
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(erc721Proxy.address, { from: owner });
+        await multiAssetProxy.registerAssetProxy.awaitTransactionSuccessAsync(erc1155Proxy.address, { from: owner });

        // Deploy and configure ERC20 tokens
        const numDummyErc20ToDeploy = 2;
@@ -192,19 +152,13 @@ describe('Asset Transfer Proxies', () => {
        );

        await erc20Wrapper.setBalancesAndAllowancesAsync();
-        await noReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
-            fromAddress,
-            constants.INITIAL_ERC20_BALANCE,
-            {
-                from: owner,
-            },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await noReturnErc20Token.setBalance.awaitTransactionSuccessAsync(fromAddress, constants.INITIAL_ERC20_BALANCE, {
+            from: owner,
+        });
        await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
            erc20Proxy.address,
            constants.INITIAL_ERC20_ALLOWANCE,
            { from: fromAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
        );
        await multipleReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
            fromAddress,
@@ -212,13 +166,11 @@ describe('Asset Transfer Proxies', () => {
            {
                from: owner,
            },
-            constants.AWAIT_TRANSACTION_MINED_MS,
        );
        await multipleReturnErc20Token.approve.awaitTransactionSuccessAsync(
            erc20Proxy.address,
            constants.INITIAL_ERC20_ALLOWANCE,
            { from: fromAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
        );

        // Deploy and configure ERC721 tokens and receiver
@@ -407,12 +359,9 @@ describe('Asset Transfer Proxies', () => {
                    toAddress,
                    amount,
                );
-                await erc20TokenA.approve.awaitTransactionSuccessAsync(
-                    erc20Proxy.address,
-                    allowance,
-                    { from: fromAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                await erc20TokenA.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                    from: fromAddress,
+                });
                const erc20Balances = await erc20Wrapper.getBalancesAsync();
                // Perform a transfer; expect this to fail.
                await expectTransactionFailedAsync(
@@ -439,12 +388,9 @@ describe('Asset Transfer Proxies', () => {
                    toAddress,
                    amount,
                );
-                await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
-                    erc20Proxy.address,
-                    allowance,
-                    { from: fromAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                await noReturnErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
+                    from: fromAddress,
+                });
                const initialFromBalance = await noReturnErc20Token.balanceOf.callAsync(fromAddress);
                const initialToBalance = await noReturnErc20Token.balanceOf.callAsync(toAddress);
                // Perform a transfer; expect this to fail.
@@ -680,19 +626,13 @@ describe('Asset Transfer Proxies', () => {
                const ownerFromAsset = await erc721TokenA.ownerOf.callAsync(erc721AFromTokenId);
                expect(ownerFromAsset).to.be.equal(fromAddress);
                // Remove blanket transfer approval for fromAddress.
-                await erc721TokenA.setApprovalForAll.awaitTransactionSuccessAsync(
-                    erc721Proxy.address,
-                    false,
-                    { from: fromAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                await erc721TokenA.setApprovalForAll.awaitTransactionSuccessAsync(erc721Proxy.address, false, {
+                    from: fromAddress,
+                });
                // Remove token transfer approval for fromAddress.
-                await erc721TokenA.approve.awaitTransactionSuccessAsync(
-                    constants.NULL_ADDRESS,
-                    erc721AFromTokenId,
-                    { from: fromAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
-                );
+                await erc721TokenA.approve.awaitTransactionSuccessAsync(constants.NULL_ADDRESS, erc721AFromTokenId, {
+                    from: fromAddress,
+                });
                // Perform a transfer; expect this to fail.
                const amount = new BigNumber(1);
                const data = assetProxyInterface.transferFrom.getABIEncodedTransactionData(
--- a/contracts/asset-proxy/test/utils/erc20_wrapper.ts
+++ b/contracts/asset-proxy/test/utils/erc20_wrapper.ts
@@ -70,13 +70,11 @@ export class ERC20Wrapper {
                    tokenOwnerAddress,
                    constants.INITIAL_ERC20_BALANCE,
                    { from: this._contractOwnerAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
                await dummyTokenContract.approve.awaitTransactionSuccessAsync(
                    (this._proxyContract as ERC20ProxyContract).address,
                    constants.INITIAL_ERC20_ALLOWANCE,
                    { from: tokenOwnerAddress },
-                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
            }
        }
@@ -88,12 +86,9 @@ export class ERC20Wrapper {
    }
    public async setBalanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(assetData);
-        await tokenContract.setBalance.awaitTransactionSuccessAsync(
-            userAddress,
-            amount,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.setBalance.awaitTransactionSuccessAsync(userAddress, amount, {
+            from: this._contractOwnerAddress,
+        });
    }
    public async getProxyAllowanceAsync(userAddress: string, assetData: string): Promise<BigNumber> {
        const tokenContract = this._getTokenContractFromAssetData(assetData);
@@ -104,12 +99,7 @@ export class ERC20Wrapper {
    public async setAllowanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(assetData);
        const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        await tokenContract.approve.awaitTransactionSuccessAsync(
-            proxyAddress,
-            amount,
-            { from: userAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.approve.awaitTransactionSuccessAsync(proxyAddress, amount, { from: userAddress });
    }
    public async getBalancesAsync(): Promise<ERC20BalancesByOwner> {
        this._validateDummyTokenContractsExistOrThrow();
--- a/contracts/asset-proxy/test/utils/erc721_wrapper.ts
+++ b/contracts/asset-proxy/test/utils/erc721_wrapper.ts
@@ -93,22 +93,14 @@ export class ERC721Wrapper {
    ): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
        const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
-        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(
-            proxyAddress,
-            isApproved,
-            { from: ownerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(proxyAddress, isApproved, {
+            from: ownerAddress,
+        });
    }
    public async approveAsync(to: string, tokenAddress: string, tokenId: BigNumber): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
        const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
-        await tokenContract.approve.awaitTransactionSuccessAsync(
-            to,
-            tokenId,
-            { from: tokenOwner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.approve.awaitTransactionSuccessAsync(to, tokenId, { from: tokenOwner });
    }
    public async transferFromAsync(
        tokenAddress: string,
@@ -117,31 +109,19 @@ export class ERC721Wrapper {
        userAddress: string,
    ): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.transferFrom.awaitTransactionSuccessAsync(
-            currentOwner,
-            userAddress,
-            tokenId,
-            { from: currentOwner },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.transferFrom.awaitTransactionSuccessAsync(currentOwner, userAddress, tokenId, {
+            from: currentOwner,
+        });
    }
    public async mintAsync(tokenAddress: string, tokenId: BigNumber, userAddress: string): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.mint.awaitTransactionSuccessAsync(
-            userAddress,
-            tokenId,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.mint.awaitTransactionSuccessAsync(userAddress, tokenId, {
+            from: this._contractOwnerAddress,
+        });
    }
    public async burnAsync(tokenAddress: string, tokenId: BigNumber, owner: string): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.burn.awaitTransactionSuccessAsync(
-            owner,
-            tokenId,
-            { from: this._contractOwnerAddress },
-            constants.AWAIT_TRANSACTION_MINED_MS,
-        );
+        await tokenContract.burn.awaitTransactionSuccessAsync(owner, tokenId, { from: this._contractOwnerAddress });
    }
    public async ownerOfAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);