Fix geth tests
This commit is contained in:
		@@ -68,7 +68,10 @@ contract AssetProxyOwner is
 | 
			
		||||
    {
 | 
			
		||||
        for (uint256 i = 0; i < _assetProxyContracts.length; i++) {
 | 
			
		||||
            address assetProxy = _assetProxyContracts[i];
 | 
			
		||||
            require(assetProxy != address(0));
 | 
			
		||||
            require(
 | 
			
		||||
                assetProxy != address(0),
 | 
			
		||||
                "INVALID_ASSET_PROXY"
 | 
			
		||||
            );
 | 
			
		||||
            isAssetProxyRegistered[assetProxy] = true;
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 
 | 
			
		||||
@@ -14,7 +14,7 @@ import { ValidatorContract } from '../../generated_contract_wrappers/validator';
 | 
			
		||||
import { WalletContract } from '../../generated_contract_wrappers/wallet';
 | 
			
		||||
import { addressUtils } from '../utils/address_utils';
 | 
			
		||||
import { artifacts } from '../utils/artifacts';
 | 
			
		||||
import { expectContractCallFailed, expectContractCallFailedWithoutReasonAsync } from '../utils/assertions';
 | 
			
		||||
import { expectContractCallFailedAsync, expectContractCallFailedWithoutReasonAsync } from '../utils/assertions';
 | 
			
		||||
import { chaiSetup } from '../utils/chai_setup';
 | 
			
		||||
import { constants } from '../utils/constants';
 | 
			
		||||
import { LogDecoder } from '../utils/log_decoder';
 | 
			
		||||
@@ -119,7 +119,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
        it('should revert when signature is empty', async () => {
 | 
			
		||||
            const emptySignature = '0x';
 | 
			
		||||
            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(
 | 
			
		||||
                    orderHashHex,
 | 
			
		||||
                    signedOrder.makerAddress,
 | 
			
		||||
@@ -133,7 +133,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
            const unsupportedSignatureType = SignatureType.NSignatureTypes;
 | 
			
		||||
            const unsupportedSignatureHex = '0x' + Buffer.from([unsupportedSignatureType]).toString('hex');
 | 
			
		||||
            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(
 | 
			
		||||
                    orderHashHex,
 | 
			
		||||
                    signedOrder.makerAddress,
 | 
			
		||||
@@ -146,7 +146,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
        it('should revert when SignatureType=Illegal', async () => {
 | 
			
		||||
            const unsupportedSignatureHex = '0x' + Buffer.from([SignatureType.Illegal]).toString('hex');
 | 
			
		||||
            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(
 | 
			
		||||
                    orderHashHex,
 | 
			
		||||
                    signedOrder.makerAddress,
 | 
			
		||||
@@ -173,7 +173,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
            const signatureBuffer = Buffer.concat([fillerData, signatureType]);
 | 
			
		||||
            const signatureHex = ethUtil.bufferToHex(signatureBuffer);
 | 
			
		||||
            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(
 | 
			
		||||
                    orderHashHex,
 | 
			
		||||
                    signedOrder.makerAddress,
 | 
			
		||||
@@ -339,7 +339,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
                ethUtil.toBuffer(`0x${SignatureType.Wallet}`),
 | 
			
		||||
            ]);
 | 
			
		||||
            const signatureHex = ethUtil.bufferToHex(signature);
 | 
			
		||||
            await expectContractCallFailed(
 | 
			
		||||
            await expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(
 | 
			
		||||
                    orderHashHex,
 | 
			
		||||
                    maliciousWallet.address,
 | 
			
		||||
@@ -385,7 +385,7 @@ describe('MixinSignatureValidator', () => {
 | 
			
		||||
            const signature = Buffer.concat([validatorAddress, signatureType]);
 | 
			
		||||
            const signatureHex = ethUtil.bufferToHex(signature);
 | 
			
		||||
            const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
 | 
			
		||||
            await expectContractCallFailed(
 | 
			
		||||
            await expectContractCallFailedAsync(
 | 
			
		||||
                signatureValidator.publicIsValidSignature.callAsync(orderHashHex, signerAddress, signatureHex),
 | 
			
		||||
                RevertReason.ValidatorError,
 | 
			
		||||
            );
 | 
			
		||||
 
 | 
			
		||||
@@ -9,7 +9,7 @@ import * as _ from 'lodash';
 | 
			
		||||
 | 
			
		||||
import { TestLibBytesContract } from '../../generated_contract_wrappers/test_lib_bytes';
 | 
			
		||||
import { artifacts } from '../utils/artifacts';
 | 
			
		||||
import { expectContractCallFailed } from '../utils/assertions';
 | 
			
		||||
import { expectContractCallFailedAsync } from '../utils/assertions';
 | 
			
		||||
import { chaiSetup } from '../utils/chai_setup';
 | 
			
		||||
import { constants } from '../utils/constants';
 | 
			
		||||
import { typeEncodingUtils } from '../utils/type_encoding_utils';
 | 
			
		||||
@@ -103,7 +103,7 @@ describe('LibBytes', () => {
 | 
			
		||||
 | 
			
		||||
    describe('popLastByte', () => {
 | 
			
		||||
        it('should revert if length is 0', async () => {
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicPopLastByte.callAsync(constants.NULL_BYTES),
 | 
			
		||||
                RevertReason.LibBytesGreaterThanZeroLengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -125,7 +125,7 @@ describe('LibBytes', () => {
 | 
			
		||||
 | 
			
		||||
    describe('popLast20Bytes', () => {
 | 
			
		||||
        it('should revert if length is less than 20', async () => {
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicPopLast20Bytes.callAsync(byteArrayShorterThan20Bytes),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -200,7 +200,7 @@ describe('LibBytes', () => {
 | 
			
		||||
 | 
			
		||||
    describe('deepCopyBytes', () => {
 | 
			
		||||
        it('should revert if dest is shorter than source', async () => {
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicDeepCopyBytes.callAsync(byteArrayShorterThan32Bytes, byteArrayLongerThan32Bytes),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualToSourceBytesLengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -253,7 +253,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the byte array is too short to hold an address', async () => {
 | 
			
		||||
            const shortByteArray = '0xabcdef';
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadAddress.callAsync(shortByteArray, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -261,7 +261,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold an address', async () => {
 | 
			
		||||
            const byteArray = testAddress;
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadAddress.callAsync(byteArray, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -297,7 +297,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the byte array is too short to hold an address', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteAddress.callAsync(byteArrayShorterThan20Bytes, offset, testAddress),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -305,7 +305,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold an address', async () => {
 | 
			
		||||
            const byteArray = byteArrayLongerThan32Bytes;
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteAddress.callAsync(byteArray, badOffset, testAddress),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo20LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -329,14 +329,14 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the byte array is too short to hold a bytes32', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytes32.callAsync(byteArrayShorterThan32Bytes, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold a bytes32', async () => {
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(testBytes32).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytes32.callAsync(testBytes32, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -372,7 +372,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the byte array is too short to hold a bytes32', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteBytes32.callAsync(byteArrayShorterThan32Bytes, offset, testBytes32),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -380,7 +380,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold a bytes32', async () => {
 | 
			
		||||
            const byteArray = byteArrayLongerThan32Bytes;
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteBytes32.callAsync(byteArray, badOffset, testBytes32),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -408,7 +408,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the byte array is too short to hold a uint256', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadUint256.callAsync(byteArrayShorterThan32Bytes, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -418,7 +418,7 @@ describe('LibBytes', () => {
 | 
			
		||||
            const testUint256AsBuffer = ethUtil.toBuffer(formattedTestUint256);
 | 
			
		||||
            const byteArray = ethUtil.bufferToHex(testUint256AsBuffer);
 | 
			
		||||
            const badOffset = new BigNumber(testUint256AsBuffer.byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadUint256.callAsync(byteArray, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -458,7 +458,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the byte array is too short to hold a uint256', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteUint256.callAsync(byteArrayShorterThan32Bytes, offset, testUint256),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -466,7 +466,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold a uint256', async () => {
 | 
			
		||||
            const byteArray = byteArrayLongerThan32Bytes;
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(byteArray).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteUint256.callAsync(byteArray, badOffset, testUint256),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -478,7 +478,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should revert if byte array has a length < 4', async () => {
 | 
			
		||||
            const byteArrayLessThan4Bytes = '0x010101';
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytes4.callAsync(byteArrayLessThan4Bytes, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo4LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -504,7 +504,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold a bytes4', async () => {
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(testBytes4).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytes4.callAsync(testBytes4, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo4LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -554,28 +554,28 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the byte array is too short to hold the length of a nested byte array', async () => {
 | 
			
		||||
            // The length of the nested array is 32 bytes. By storing less than 32 bytes, a length cannot be read.
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytesWithLength.callAsync(byteArrayShorterThan32Bytes, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if we store a nested byte array length, without a nested byte array', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytesWithLength.callAsync(testBytes32, offset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold the length of a nested byte array', async () => {
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(byteArrayShorterThan32Bytes).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytesWithLength.callAsync(byteArrayShorterThan32Bytes, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold the nested byte array', async () => {
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(testBytes32).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicReadBytesWithLength.callAsync(testBytes32, badOffset),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualTo32LengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -687,7 +687,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the byte array is too short to hold the length of a nested byte array', async () => {
 | 
			
		||||
            const offset = new BigNumber(0);
 | 
			
		||||
            const emptyByteArray = ethUtil.bufferToHex(new Buffer(1));
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteBytesWithLength.callAsync(emptyByteArray, offset, longData),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
@@ -695,7 +695,7 @@ describe('LibBytes', () => {
 | 
			
		||||
        it('should fail if the length between the offset and end of the byte array is too short to hold the length of a nested byte array', async () => {
 | 
			
		||||
            const emptyByteArray = ethUtil.bufferToHex(new Buffer(shortTestBytesAsBuffer.byteLength));
 | 
			
		||||
            const badOffset = new BigNumber(ethUtil.toBuffer(shortTestBytesAsBuffer).byteLength);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                libBytes.publicWriteBytesWithLength.callAsync(emptyByteArray, badOffset, shortData),
 | 
			
		||||
                RevertReason.LibBytesGreaterOrEqualToNestedBytesLengthRequired,
 | 
			
		||||
            );
 | 
			
		||||
 
 | 
			
		||||
@@ -1,4 +1,5 @@
 | 
			
		||||
import { BlockchainLifecycle } from '@0xproject/dev-utils';
 | 
			
		||||
import { RevertReason } from '@0xproject/types';
 | 
			
		||||
import { BigNumber } from '@0xproject/utils';
 | 
			
		||||
import * as chai from 'chai';
 | 
			
		||||
import { LogWithDecodedArgs } from 'ethereum-types';
 | 
			
		||||
@@ -14,9 +15,11 @@ import { MixinAuthorizableContract } from '../../generated_contract_wrappers/mix
 | 
			
		||||
import { TestAssetProxyOwnerContract } from '../../generated_contract_wrappers/test_asset_proxy_owner';
 | 
			
		||||
import { artifacts } from '../utils/artifacts';
 | 
			
		||||
import {
 | 
			
		||||
    expectContractCallFailedWithoutReasonAsync,
 | 
			
		||||
    expectContractCreationFailedWithoutReason,
 | 
			
		||||
    expectContractCallFailedAsync,
 | 
			
		||||
    expectContractCreationFailedAsync,
 | 
			
		||||
    expectTransactionFailedAsync,
 | 
			
		||||
    expectTransactionFailedWithoutReasonAsync,
 | 
			
		||||
    sendTransactionResult,
 | 
			
		||||
} from '../utils/assertions';
 | 
			
		||||
import { increaseTimeAndMineBlockAsync } from '../utils/block_timestamp';
 | 
			
		||||
import { chaiSetup } from '../utils/chai_setup';
 | 
			
		||||
@@ -109,8 +112,8 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
        });
 | 
			
		||||
        it('should throw if a null address is included in assetProxyContracts', async () => {
 | 
			
		||||
            const assetProxyContractAddresses = [erc20Proxy.address, constants.NULL_ADDRESS];
 | 
			
		||||
            return expectContractCreationFailedWithoutReason(
 | 
			
		||||
                AssetProxyOwnerContract.deployFrom0xArtifactAsync(
 | 
			
		||||
            return expectContractCreationFailedAsync(
 | 
			
		||||
                (AssetProxyOwnerContract.deployFrom0xArtifactAsync(
 | 
			
		||||
                    artifacts.AssetProxyOwner,
 | 
			
		||||
                    provider,
 | 
			
		||||
                    txDefaults,
 | 
			
		||||
@@ -118,7 +121,8 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
                    assetProxyContractAddresses,
 | 
			
		||||
                    REQUIRED_APPROVALS,
 | 
			
		||||
                    SECONDS_TIME_LOCKED,
 | 
			
		||||
                ),
 | 
			
		||||
                ) as any) as sendTransactionResult,
 | 
			
		||||
                RevertReason.InvalidAssetProxy,
 | 
			
		||||
            );
 | 
			
		||||
        });
 | 
			
		||||
    });
 | 
			
		||||
@@ -281,8 +285,9 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
                );
 | 
			
		||||
                const log = submitTxRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
 | 
			
		||||
                const txId = log.args.transactionId;
 | 
			
		||||
                return expectContractCallFailedWithoutReasonAsync(
 | 
			
		||||
                return expectContractCallFailedAsync(
 | 
			
		||||
                    testAssetProxyOwner.testValidRemoveAuthorizedAddressAtIndexTx.callAsync(txId),
 | 
			
		||||
                    RevertReason.InvalidFunctionSelector,
 | 
			
		||||
                );
 | 
			
		||||
            });
 | 
			
		||||
 | 
			
		||||
@@ -316,8 +321,9 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
                );
 | 
			
		||||
                const log = submitTxRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerSubmissionEventArgs>;
 | 
			
		||||
                const txId = log.args.transactionId;
 | 
			
		||||
                return expectContractCallFailedWithoutReasonAsync(
 | 
			
		||||
                return expectContractCallFailedAsync(
 | 
			
		||||
                    testAssetProxyOwner.testValidRemoveAuthorizedAddressAtIndexTx.callAsync(txId),
 | 
			
		||||
                    RevertReason.UnregisteredAssetProxy,
 | 
			
		||||
                );
 | 
			
		||||
            });
 | 
			
		||||
        });
 | 
			
		||||
@@ -358,10 +364,11 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
 | 
			
		||||
                await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 | 
			
		||||
 | 
			
		||||
                return expectTransactionFailedWithoutReasonAsync(
 | 
			
		||||
                return expectTransactionFailedAsync(
 | 
			
		||||
                    testAssetProxyOwner.executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
 | 
			
		||||
                        from: owners[1],
 | 
			
		||||
                    }),
 | 
			
		||||
                    RevertReason.UnregisteredAssetProxy,
 | 
			
		||||
                );
 | 
			
		||||
            });
 | 
			
		||||
 | 
			
		||||
@@ -380,10 +387,11 @@ describe('AssetProxyOwner', () => {
 | 
			
		||||
 | 
			
		||||
                await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 | 
			
		||||
 | 
			
		||||
                return expectTransactionFailedWithoutReasonAsync(
 | 
			
		||||
                return expectTransactionFailedAsync(
 | 
			
		||||
                    testAssetProxyOwner.executeRemoveAuthorizedAddressAtIndex.sendTransactionAsync(txId, {
 | 
			
		||||
                        from: owners[1],
 | 
			
		||||
                    }),
 | 
			
		||||
                    RevertReason.InvalidFunctionSelector,
 | 
			
		||||
                );
 | 
			
		||||
            });
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@ import * as chai from 'chai';
 | 
			
		||||
 | 
			
		||||
import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
 | 
			
		||||
import { artifacts } from '../utils/artifacts';
 | 
			
		||||
import { expectContractCallFailed } from '../utils/assertions';
 | 
			
		||||
import { expectContractCallFailedAsync } from '../utils/assertions';
 | 
			
		||||
import { chaiSetup } from '../utils/chai_setup';
 | 
			
		||||
import { constants } from '../utils/constants';
 | 
			
		||||
import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
 | 
			
		||||
@@ -54,7 +54,7 @@ describe('UnlimitedAllowanceToken', () => {
 | 
			
		||||
        it('should throw if owner has insufficient balance', async () => {
 | 
			
		||||
            const ownerBalance = await token.balanceOf.callAsync(owner);
 | 
			
		||||
            const amountToTransfer = ownerBalance.plus(1);
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                token.transfer.callAsync(spender, amountToTransfer, { from: owner }),
 | 
			
		||||
                RevertReason.Erc20InsufficientBalance,
 | 
			
		||||
            );
 | 
			
		||||
@@ -93,7 +93,7 @@ describe('UnlimitedAllowanceToken', () => {
 | 
			
		||||
                await token.approve.sendTransactionAsync(spender, amountToTransfer, { from: owner }),
 | 
			
		||||
                constants.AWAIT_TRANSACTION_MINED_MS,
 | 
			
		||||
            );
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                token.transferFrom.callAsync(owner, spender, amountToTransfer, {
 | 
			
		||||
                    from: spender,
 | 
			
		||||
                }),
 | 
			
		||||
@@ -109,7 +109,7 @@ describe('UnlimitedAllowanceToken', () => {
 | 
			
		||||
            const isSpenderAllowanceInsufficient = spenderAllowance.cmp(amountToTransfer) < 0;
 | 
			
		||||
            expect(isSpenderAllowanceInsufficient).to.be.true();
 | 
			
		||||
 | 
			
		||||
            return expectContractCallFailed(
 | 
			
		||||
            return expectContractCallFailedAsync(
 | 
			
		||||
                token.transferFrom.callAsync(owner, spender, amountToTransfer, {
 | 
			
		||||
                    from: spender,
 | 
			
		||||
                }),
 | 
			
		||||
 
 | 
			
		||||
@@ -159,7 +159,7 @@ export async function expectTransactionFailedWithoutReasonAsync(p: sendTransacti
 | 
			
		||||
 * @returns a new Promise which will reject if the conditions are not met and
 | 
			
		||||
 * otherwise resolve with no value.
 | 
			
		||||
 */
 | 
			
		||||
export async function expectContractCallFailed<T>(p: Promise<T>, reason: RevertReason): Promise<void> {
 | 
			
		||||
export async function expectContractCallFailedAsync<T>(p: Promise<T>, reason: RevertReason): Promise<void> {
 | 
			
		||||
    return expect(p).to.be.rejectedWith(reason);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@@ -180,7 +180,20 @@ export async function expectContractCallFailedWithoutReasonAsync<T>(p: Promise<T
 | 
			
		||||
 * @returns a new Promise which will reject if the conditions are not met and
 | 
			
		||||
 * otherwise resolve with no value.
 | 
			
		||||
 */
 | 
			
		||||
export async function expectContractCreationFailedWithoutReason<T>(p: Promise<T>): Promise<void> {
 | 
			
		||||
export async function expectContractCreationFailedAsync<T>(
 | 
			
		||||
    p: sendTransactionResult,
 | 
			
		||||
    reason: RevertReason,
 | 
			
		||||
): Promise<void> {
 | 
			
		||||
    return expectTransactionFailedAsync(p, reason);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/**
 | 
			
		||||
 * Resolves if the contract creation/deployment fails without a revert reason.
 | 
			
		||||
 * @param p a Promise resulting from a contract creation/deployment
 | 
			
		||||
 * @returns a new Promise which will reject if the conditions are not met and
 | 
			
		||||
 * otherwise resolve with no value.
 | 
			
		||||
 */
 | 
			
		||||
export async function expectContractCreationFailedWithoutReasonAsync<T>(p: Promise<T>): Promise<void> {
 | 
			
		||||
    const errMessage = await _getTransactionFailedErrorMessageAsync();
 | 
			
		||||
    return expect(p).to.be.rejectedWith(errMessage);
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -1,4 +1,13 @@
 | 
			
		||||
[
 | 
			
		||||
    {
 | 
			
		||||
        "version": "1.0.1-rc.7",
 | 
			
		||||
        "changes": [
 | 
			
		||||
            {
 | 
			
		||||
                "note": "Add AssetProxyOwner revert reasons",
 | 
			
		||||
                "pr": 1041
 | 
			
		||||
            }
 | 
			
		||||
        ]
 | 
			
		||||
    },
 | 
			
		||||
    {
 | 
			
		||||
        "version": "1.0.1-rc.6",
 | 
			
		||||
        "changes": [
 | 
			
		||||
 
 | 
			
		||||
@@ -224,6 +224,9 @@ export enum RevertReason {
 | 
			
		||||
    Erc721InvalidSelector = 'ERC721_INVALID_SELECTOR',
 | 
			
		||||
    WalletError = 'WALLET_ERROR',
 | 
			
		||||
    ValidatorError = 'VALIDATOR_ERROR',
 | 
			
		||||
    InvalidFunctionSelector = 'INVALID_FUNCTION_SELECTOR',
 | 
			
		||||
    InvalidAssetProxy = 'INVALID_ASSET_PROXY',
 | 
			
		||||
    UnregisteredAssetProxy = 'UNREGISTERED_ASSET_PROXY',
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
export enum StatusCodes {
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user