update abi-gen with new method interfaces

contracts/asset-proxy/src/erc1155_proxy_wrapper.ts

@@ -76,7 +76,7 @@ export class ERC1155ProxyWrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     /**
@@ -113,19 +113,13 @@ export class ERC1155ProxyWrapper {
         this._validateProxyContractExistsOrThrow();
         const assetData =
             assetData_ === undefined
-                ? await this._devUtils.encodeERC1155AssetData.callAsync(
-                      contractAddress,
-                      tokensToTransfer,
-                      valuesToTransfer,
-                      receiverCallbackData,
-                  )
+                ? await this._devUtils
+                      .encodeERC1155AssetData(contractAddress, tokensToTransfer, valuesToTransfer, receiverCallbackData)
+                      .callAsync()
                 : assetData_;
-        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
-            assetData,
-            from,
-            to,
-            valueMultiplier,
-        );
+        const data = this._assetProxyInterface
+            .transferFrom(assetData, from, to, valueMultiplier)
+            .getABIEncodedTransactionData();
         return data;
     }
     /**
@@ -173,19 +167,13 @@ export class ERC1155ProxyWrapper {
         this._validateProxyContractExistsOrThrow();
         const assetData =
             assetData_ === undefined
-                ? await this._devUtils.encodeERC1155AssetData.callAsync(
-                      contractAddress,
-                      tokensToTransfer,
-                      valuesToTransfer,
-                      receiverCallbackData,
-                  )
+                ? await this._devUtils
+                      .encodeERC1155AssetData(contractAddress, tokensToTransfer, valuesToTransfer, receiverCallbackData)
+                      .callAsync()
                 : assetData_;
-        const data = this._assetProxyInterface.transferFrom.getABIEncodedTransactionData(
-            assetData,
-            from,
-            to,
-            valueMultiplier,
-        );
+        const data = this._assetProxyInterface
+            .transferFrom(assetData, from, to, valueMultiplier)
+            .getABIEncodedTransactionData();
         const txHash = await this._web3Wrapper.sendTransactionAsync({
             to: (this._proxyContract as ERC1155ProxyContract).address,
             data,
@@ -366,7 +354,7 @@ export class ERC1155ProxyWrapper {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getContractFromAddress(contractAddress);
         const operator = (this._proxyContract as ERC1155ProxyContract).address;
-        const didApproveAll = await tokenContract.isApprovedForAll.callAsync(userAddress, operator);
+        const didApproveAll = await tokenContract.isApprovedForAll(userAddress, operator).callAsync();
         return didApproveAll;
     }
     public getFungibleTokenIds(): BigNumber[] {

contracts/asset-proxy/src/erc20_wrapper.ts

@@ -58,7 +58,7 @@ export class ERC20Wrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     public getProxyId(): string {
@@ -70,43 +70,39 @@ export class ERC20Wrapper {
         this._validateProxyContractExistsOrThrow();
         for (const dummyTokenContract of this._dummyTokenContracts) {
             for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                await dummyTokenContract.setBalance.awaitTransactionSuccessAsync(
-                    tokenOwnerAddress,
-                    constants.INITIAL_ERC20_BALANCE,
-                    { from: this._contractOwnerAddress },
-                );
-                await dummyTokenContract.approve.awaitTransactionSuccessAsync(
-                    (this._proxyContract as ERC20ProxyContract).address,
-                    constants.INITIAL_ERC20_ALLOWANCE,
-                    { from: tokenOwnerAddress },
-                );
+                await dummyTokenContract
+                    .setBalance(tokenOwnerAddress, constants.INITIAL_ERC20_BALANCE)
+                    .awaitTransactionSuccessAsync({ from: this._contractOwnerAddress });
+                await dummyTokenContract
+                    .approve((this._proxyContract as ERC20ProxyContract).address, constants.INITIAL_ERC20_ALLOWANCE)
+                    .awaitTransactionSuccessAsync({ from: tokenOwnerAddress });
             }
         }
     }
     public async getBalanceAsync(userAddress: string, assetData: string): Promise<BigNumber> {
         const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
-        const balance = new BigNumber(await tokenContract.balanceOf.callAsync(userAddress));
+        const balance = new BigNumber(await tokenContract.balanceOf(userAddress).callAsync());
         return balance;
     }
     public async setBalanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
         const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
-        await tokenContract.setBalance.awaitTransactionSuccessAsync(
-            userAddress,
-            amount,
-            { from: this._contractOwnerAddress },
-            { pollingIntervalMs: constants.AWAIT_TRANSACTION_MINED_MS },
-        );
+        await tokenContract
+            .setBalance(userAddress, amount)
+            .awaitTransactionSuccessAsync(
+                { from: this._contractOwnerAddress },
+                { pollingIntervalMs: constants.AWAIT_TRANSACTION_MINED_MS },
+            );
     }
     public async getProxyAllowanceAsync(userAddress: string, assetData: string): Promise<BigNumber> {
         const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
         const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        const allowance = new BigNumber(await tokenContract.allowance.callAsync(userAddress, proxyAddress));
+        const allowance = new BigNumber(await tokenContract.allowance(userAddress, proxyAddress).callAsync());
         return allowance;
     }
     public async setAllowanceAsync(userAddress: string, assetData: string, amount: BigNumber): Promise<void> {
         const tokenContract = await this._getTokenContractFromAssetDataAsync(assetData);
         const proxyAddress = (this._proxyContract as ERC20ProxyContract).address;
-        await tokenContract.approve.awaitTransactionSuccessAsync(proxyAddress, amount, { from: userAddress });
+        await tokenContract.approve(proxyAddress, amount).awaitTransactionSuccessAsync({ from: userAddress });
     }
     public async getBalancesAsync(): Promise<ERC20BalancesByOwner> {
         this._validateDummyTokenContractsExistOrThrow();
@@ -115,7 +111,7 @@ export class ERC20Wrapper {
         const balanceInfo: Array<{ tokenOwnerAddress: string; tokenAddress: string }> = [];
         for (const dummyTokenContract of this._dummyTokenContracts) {
             for (const tokenOwnerAddress of this._tokenOwnerAddresses) {
-                balances.push(await dummyTokenContract.balanceOf.callAsync(tokenOwnerAddress));
+                balances.push(await dummyTokenContract.balanceOf(tokenOwnerAddress).callAsync());
                 balanceInfo.push({
                     tokenOwnerAddress,
                     tokenAddress: dummyTokenContract.address,
@@ -149,7 +145,7 @@ export class ERC20Wrapper {
         return tokenAddresses;
     }
     private async _getTokenContractFromAssetDataAsync(assetData: string): Promise<DummyERC20TokenContract> {
-        const [proxyId, tokenAddress] = await this._devUtils.decodeERC20AssetData.callAsync(assetData); // tslint:disable-line:no-unused-variable
+        const [proxyId, tokenAddress] = await this._devUtils.decodeERC20AssetData(assetData).callAsync(); // tslint:disable-line:no-unused-variable
         const tokenContractIfExists = _.find(this._dummyTokenContracts, c => c.address === tokenAddress);
         if (tokenContractIfExists === undefined) {
             throw new Error(`Token: ${tokenAddress} was not deployed through ERC20Wrapper`);

contracts/asset-proxy/src/erc721_wrapper.ts

@@ -46,7 +46,7 @@ export class ERC721Wrapper {
             txDefaults,
             artifacts,
         );
-        this._proxyIdIfExists = await this._proxyContract.getProxyId.callAsync();
+        this._proxyIdIfExists = await this._proxyContract.getProxyId().callAsync();
         return this._proxyContract;
     }
     public getProxyId(): string {
@@ -80,7 +80,7 @@ export class ERC721Wrapper {
     }
     public async doesTokenExistAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf(tokenId).callAsync();
         const doesExist = owner !== constants.NULL_ADDRESS;
         return doesExist;
     }
@@ -95,14 +95,14 @@ export class ERC721Wrapper {
     ): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
-        await tokenContract.setApprovalForAll.awaitTransactionSuccessAsync(proxyAddress, isApproved, {
+        await tokenContract.setApprovalForAll(proxyAddress, isApproved).awaitTransactionSuccessAsync({
             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 });
+        await tokenContract.approve(to, tokenId).awaitTransactionSuccessAsync({ from: tokenOwner });
     }
     public async transferFromAsync(
         tokenAddress: string,
@@ -111,42 +111,42 @@ export class ERC721Wrapper {
         userAddress: string,
     ): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.transferFrom.awaitTransactionSuccessAsync(currentOwner, userAddress, tokenId, {
+        await tokenContract.transferFrom(currentOwner, userAddress, tokenId).awaitTransactionSuccessAsync({
             from: currentOwner,
         });
     }
     public async mintAsync(tokenAddress: string, tokenId: BigNumber, userAddress: string): Promise<void> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        await tokenContract.mint.awaitTransactionSuccessAsync(userAddress, tokenId, {
+        await tokenContract.mint(userAddress, tokenId).awaitTransactionSuccessAsync({
             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 });
+        await tokenContract.burn(owner, tokenId).awaitTransactionSuccessAsync({ from: this._contractOwnerAddress });
     }
     public async ownerOfAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf(tokenId).callAsync();
         return owner;
     }
     public async isOwnerAsync(userAddress: string, tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const tokenOwner = await tokenContract.ownerOf.callAsync(tokenId);
+        const tokenOwner = await tokenContract.ownerOf(tokenId).callAsync();
         const isOwner = tokenOwner === userAddress;
         return isOwner;
     }
     public async isProxyApprovedForAllAsync(userAddress: string, tokenAddress: string): Promise<boolean> {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
         const operator = (this._proxyContract as ERC721ProxyContract).address;
-        const didApproveAll = await tokenContract.isApprovedForAll.callAsync(userAddress, operator);
+        const didApproveAll = await tokenContract.isApprovedForAll(userAddress, operator).callAsync();
         return didApproveAll;
     }
     public async isProxyApprovedAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         this._validateProxyContractExistsOrThrow();
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const approvedAddress = await tokenContract.getApproved.callAsync(tokenId);
+        const approvedAddress = await tokenContract.getApproved(tokenId).callAsync();
         const proxyAddress = (this._proxyContract as ERC721ProxyContract).address;
         const isProxyAnApprovedOperator = approvedAddress === proxyAddress;
         return isProxyAnApprovedOperator;
@@ -163,7 +163,7 @@ export class ERC721Wrapper {
                     dummyTokenContract.address
                 ];
                 for (const tokenId of initialTokenOwnerIds) {
-                    tokenOwnerAddresses.push(await dummyTokenContract.ownerOf.callAsync(tokenId));
+                    tokenOwnerAddresses.push(await dummyTokenContract.ownerOf(tokenId).callAsync());
                     tokenInfo.push({
                         tokenId,
                         tokenAddress: dummyTokenContract.address,