Merge pull request #1797 from 0xProject/feature/abi-gen-templates/awaitTransactionSuccess

Add awaitTransactionSuccessAsync() to generated contract functions.
2019-04-30 14:13:13 -04:00
parent 6459522617 25628c34ee
commit d6115cff25
31 changed files with 3129 additions and 237 deletions
--- a/contracts/asset-proxy/test/authorizable.ts
+++ b/contracts/asset-proxy/test/authorizable.ts
@@ -53,16 +53,18 @@ describe('Authorizable', () => {
            );
        });
        it('should allow owner to add an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const isAuthorized = await authorizable.authorized.callAsync(address);
            expect(isAuthorized).to.be.true();
        });
        it('should throw if owner attempts to authorize a duplicate address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            return expectTransactionFailedAsync(
@@ -74,8 +76,9 @@ describe('Authorizable', () => {

    describe('removeAuthorizedAddress', () => {
        it('should throw if not called by owner', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            return expectTransactionFailedAsync(
@@ -87,14 +90,14 @@ describe('Authorizable', () => {
        });

        it('should allow owner to remove an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const isAuthorized = await authorizable.authorized.callAsync(address);
@@ -113,8 +116,9 @@ describe('Authorizable', () => {

    describe('removeAuthorizedAddressAtIndex', () => {
        it('should throw if not called by owner', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const index = new BigNumber(0);
@@ -126,8 +130,9 @@ describe('Authorizable', () => {
            );
        });
        it('should throw if index is >= authorities.length', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const index = new BigNumber(1);
@@ -150,12 +155,14 @@ describe('Authorizable', () => {
        it('should throw if address at index does not match target', async () => {
            const address1 = address;
            const address2 = notOwner;
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address1, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address1,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address2, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address2,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const address1Index = new BigNumber(0);
@@ -167,15 +174,16 @@ describe('Authorizable', () => {
            );
        });
        it('should allow owner to remove an authorized address', async () => {
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const index = new BigNumber(0);
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddressAtIndex.sendTransactionAsync(address, index, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddressAtIndex.awaitTransactionSuccessAsync(
+                address,
+                index,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const isAuthorized = await authorizable.authorized.callAsync(address);
@@ -187,20 +195,17 @@ describe('Authorizable', () => {
        it('should return all authorized addresses', async () => {
            const initial = await authorizable.getAuthorizedAddresses.callAsync();
            expect(initial).to.have.length(0);
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.addAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.addAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const afterAdd = await authorizable.getAuthorizedAddresses.callAsync();
            expect(afterAdd).to.have.length(1);
            expect(afterAdd).to.include(address);
-
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await authorizable.removeAuthorizedAddress.sendTransactionAsync(address, {
-                    from: owner,
-                }),
+            await authorizable.removeAuthorizedAddress.awaitTransactionSuccessAsync(
+                address,
+                { from: owner },
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            const afterRemove = await authorizable.getAuthorizedAddresses.callAsync();
--- a/contracts/asset-proxy/test/erc1155_proxy.ts
+++ b/contracts/asset-proxy/test/erc1155_proxy.ts
@@ -70,16 +70,14 @@ describe('ERC1155Proxy', () => {
        const usedAddresses = ([owner, notAuthorized, authorized, spender, receiver] = _.slice(accounts, 0, 5));
        erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
        erc1155Proxy = await erc1155ProxyWrapper.deployProxyAsync();
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc1155Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
-                from: owner,
-            }),
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            authorized,
+            { from: owner },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await erc1155Proxy.addAuthorizedAddress.sendTransactionAsync(erc1155Proxy.address, {
-                from: owner,
-            }),
+        await erc1155Proxy.addAuthorizedAddress.awaitTransactionSuccessAsync(
+            erc1155Proxy.address,
+            { from: owner },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
        // deploy & configure ERC1155 tokens and receiver
@@ -596,8 +594,8 @@ describe('ERC1155Proxy', () => {
        it('should propagate revert reason from erc1155 contract failure', async () => {
            // disable transfers
            const shouldRejectTransfer = true;
-            await web3Wrapper.awaitTransactionSuccessAsync(
-                await erc1155Receiver.setRejectTransferFlag.sendTransactionAsync(shouldRejectTransfer),
+            await erc1155Receiver.setRejectTransferFlag.awaitTransactionSuccessAsync(
+                shouldRejectTransfer,
                constants.AWAIT_TRANSACTION_MINED_MS,
            );
            // setup test parameters
--- a/contracts/asset-proxy/test/proxies.ts
+++ b/contracts/asset-proxy/test/proxies.ts
@@ -111,72 +111,62 @@ describe('Asset Transfer Proxies', () => {
        );

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

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

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

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

@@ -206,31 +196,26 @@ describe('Asset Transfer Proxies', () => {
        );

        await erc20Wrapper.setBalancesAndAllowancesAsync();
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await noReturnErc20Token.setBalance.sendTransactionAsync(fromAddress, constants.INITIAL_ERC20_BALANCE),
+        await noReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
+            fromAddress,
+            constants.INITIAL_ERC20_BALANCE,
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await noReturnErc20Token.approve.sendTransactionAsync(
-                erc20Proxy.address,
-                constants.INITIAL_ERC20_ALLOWANCE,
-                { from: fromAddress },
-            ),
+        await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
+            erc20Proxy.address,
+            constants.INITIAL_ERC20_ALLOWANCE,
+            { from: fromAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multipleReturnErc20Token.setBalance.sendTransactionAsync(
-                fromAddress,
-                constants.INITIAL_ERC20_BALANCE,
-            ),
+        await multipleReturnErc20Token.setBalance.awaitTransactionSuccessAsync(
+            fromAddress,
+            constants.INITIAL_ERC20_BALANCE,
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
-        await web3Wrapper.awaitTransactionSuccessAsync(
-            await multipleReturnErc20Token.approve.sendTransactionAsync(
-                erc20Proxy.address,
-                constants.INITIAL_ERC20_ALLOWANCE,
-                { from: fromAddress },
-            ),
+        await multipleReturnErc20Token.approve.awaitTransactionSuccessAsync(
+            erc20Proxy.address,
+            constants.INITIAL_ERC20_ALLOWANCE,
+            { from: fromAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );

@@ -419,10 +404,10 @@ describe('Asset Transfer Proxies', () => {
                    toAddress,
                    amount,
                );
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await erc20TokenA.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
-                        from: fromAddress,
-                    }),
+                await erc20TokenA.approve.awaitTransactionSuccessAsync(
+                    erc20Proxy.address,
+                    allowance,
+                    { from: fromAddress },
                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
                const erc20Balances = await erc20Wrapper.getBalancesAsync();
@@ -451,10 +436,10 @@ describe('Asset Transfer Proxies', () => {
                    toAddress,
                    amount,
                );
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await noReturnErc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
-                        from: fromAddress,
-                    }),
+                await noReturnErc20Token.approve.awaitTransactionSuccessAsync(
+                    erc20Proxy.address,
+                    allowance,
+                    { from: fromAddress },
                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
                const initialFromBalance = await noReturnErc20Token.balanceOf.callAsync(fromAddress);
@@ -692,10 +677,10 @@ describe('Asset Transfer Proxies', () => {
                const ownerFromAsset = await erc721TokenA.ownerOf.callAsync(erc721AFromTokenId);
                expect(ownerFromAsset).to.be.equal(fromAddress);
                // Remove transfer approval for fromAddress.
-                await web3Wrapper.awaitTransactionSuccessAsync(
-                    await erc721TokenA.approve.sendTransactionAsync(constants.NULL_ADDRESS, erc721AFromTokenId, {
-                        from: fromAddress,
-                    }),
+                await erc721TokenA.approve.awaitTransactionSuccessAsync(
+                    constants.NULL_ADDRESS,
+                    erc721AFromTokenId,
+                    { from: fromAddress },
                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
                // Perform a transfer; expect this to fail.
--- a/contracts/asset-proxy/test/utils/erc20_wrapper.ts
+++ b/contracts/asset-proxy/test/utils/erc20_wrapper.ts
@@ -2,7 +2,6 @@ import { artifacts as erc20Artifacts, DummyERC20TokenContract } from '@0x/contra
 import { constants, ERC20BalancesByOwner, txDefaults } from '@0x/contracts-test-utils';
 import { assetDataUtils } from '@0x/order-utils';
 import { BigNumber } from '@0x/utils';
-import { Web3Wrapper } from '@0x/web3-wrapper';
 import { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';

@@ -11,7 +10,6 @@ import { artifacts, ERC20ProxyContract } from '../../src';
 export class ERC20Wrapper {
    private readonly _tokenOwnerAddresses: string[];
    private readonly _contractOwnerAddress: string;
-    private readonly _web3Wrapper: Web3Wrapper;
    private readonly _provider: ZeroExProvider;
    private readonly _dummyTokenContracts: DummyERC20TokenContract[];
    private _proxyContract?: ERC20ProxyContract;
@@ -25,7 +23,6 @@ export class ERC20Wrapper {
     */
    constructor(provider: ZeroExProvider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
        this._dummyTokenContracts = [];
-        this._web3Wrapper = new Web3Wrapper(provider);
        this._provider = provider;
        this._tokenOwnerAddresses = tokenOwnerAddresses;
        this._contractOwnerAddress = contractOwnerAddress;
@@ -67,20 +64,16 @@ export class ERC20Wrapper {
        this._validateProxyContractExistsOrThrow();
        for (const dummyTokenContract of this._dummyTokenContracts) {
            for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                await this._web3Wrapper.awaitTransactionSuccessAsync(
-                    await dummyTokenContract.setBalance.sendTransactionAsync(
-                        tokenOwnerAddress,
-                        constants.INITIAL_ERC20_BALANCE,
-                        { from: this._contractOwnerAddress },
-                    ),
+                await dummyTokenContract.setBalance.awaitTransactionSuccessAsync(
+                    tokenOwnerAddress,
+                    constants.INITIAL_ERC20_BALANCE,
+                    { from: this._contractOwnerAddress },
                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
-                await this._web3Wrapper.awaitTransactionSuccessAsync(
-                    await dummyTokenContract.approve.sendTransactionAsync(
-                        (this._proxyContract as ERC20ProxyContract).address,
-                        constants.INITIAL_ERC20_ALLOWANCE,
-                        { from: tokenOwnerAddress },
-                    ),
+                await dummyTokenContract.approve.awaitTransactionSuccessAsync(
+                    (this._proxyContract as ERC20ProxyContract).address,
+                    constants.INITIAL_ERC20_ALLOWANCE,
+                    { from: tokenOwnerAddress },
                    constants.AWAIT_TRANSACTION_MINED_MS,
                );
            }
@@ -93,10 +86,10 @@ export class ERC20Wrapper {
    }
    public async setBalanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(assetData);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.setBalance.sendTransactionAsync(userAddress, amount, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.setBalance.awaitTransactionSuccessAsync(
+            userAddress,
+            amount,
+            { from: this._contractOwnerAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
@@ -109,10 +102,10 @@ 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 this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.approve.sendTransactionAsync(proxyAddress, amount, {
-                from: userAddress,
-            }),
+        await tokenContract.approve.awaitTransactionSuccessAsync(
+            proxyAddress,
+            amount,
+            { from: userAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
--- a/contracts/asset-proxy/test/utils/erc721_wrapper.ts
+++ b/contracts/asset-proxy/test/utils/erc721_wrapper.ts
@@ -2,7 +2,6 @@ import { artifacts as erc721Artifacts, DummyERC721TokenContract } from '@0x/cont
 import { constants, ERC721TokenIdsByOwner, txDefaults } from '@0x/contracts-test-utils';
 import { generatePseudoRandomSalt } from '@0x/order-utils';
 import { BigNumber } from '@0x/utils';
-import { Web3Wrapper } from '@0x/web3-wrapper';
 import { ZeroExProvider } from 'ethereum-types';
 import * as _ from 'lodash';

@@ -11,14 +10,12 @@ import { artifacts, ERC721ProxyContract } from '../../src';
 export class ERC721Wrapper {
    private readonly _tokenOwnerAddresses: string[];
    private readonly _contractOwnerAddress: string;
-    private readonly _web3Wrapper: Web3Wrapper;
    private readonly _provider: ZeroExProvider;
    private readonly _dummyTokenContracts: DummyERC721TokenContract[];
    private _proxyContract?: ERC721ProxyContract;
    private _proxyIdIfExists?: string;
    private _initialTokenIdsByOwner: ERC721TokenIdsByOwner = {};
    constructor(provider: ZeroExProvider, tokenOwnerAddresses: string[], contractOwnerAddress: string) {
-        this._web3Wrapper = new Web3Wrapper(provider);
        this._provider = provider;
        this._dummyTokenContracts = [];
        this._tokenOwnerAddresses = tokenOwnerAddresses;
@@ -91,20 +88,20 @@ export class ERC721Wrapper {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
        const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
        const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.setApprovalForAll.sendTransactionAsync(proxyAddress, isApproved, {
-                from: tokenOwner,
-            }),
+        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(
+            proxyAddress,
+            isApproved,
+            { from: tokenOwner },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
    public async approveAsync(to: string, tokenAddress: string, tokenId: BigNumber): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
        const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.approve.sendTransactionAsync(to, tokenId, {
-                from: tokenOwner,
-            }),
+        await tokenContract.approve.awaitTransactionSuccessAsync(
+            to,
+            tokenId,
+            { from: tokenOwner },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
@@ -115,28 +112,29 @@ export class ERC721Wrapper {
        userAddress: string,
    ): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.transferFrom.sendTransactionAsync(currentOwner, userAddress, tokenId, {
-                from: currentOwner,
-            }),
+        await tokenContract.transferFrom.awaitTransactionSuccessAsync(
+            currentOwner,
+            userAddress,
+            tokenId,
+            { from: currentOwner },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
    public async mintAsync(tokenAddress: string, tokenId: BigNumber, userAddress: string): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.mint.sendTransactionAsync(userAddress, tokenId, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.mint.awaitTransactionSuccessAsync(
+            userAddress,
+            tokenId,
+            { from: this._contractOwnerAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }
    public async burnAsync(tokenAddress: string, tokenId: BigNumber, owner: string): Promise<void> {
        const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await this._web3Wrapper.awaitTransactionSuccessAsync(
-            await tokenContract.burn.sendTransactionAsync(owner, tokenId, {
-                from: this._contractOwnerAddress,
-            }),
+        await tokenContract.burn.awaitTransactionSuccessAsync(
+            owner,
+            tokenId,
+            { from: this._contractOwnerAddress },
            constants.AWAIT_TRANSACTION_MINED_MS,
        );
    }