Add config file specifically in prettier command and fix files

1 files changed, 304 insertions, 304 deletions

diff --git a/packages/0x.js/src/0x.ts b/packages/0x.js/src/0x.ts
index dec26e3eb..f8a484c5d 100644
--- a/packages/0x.js/src/0x.ts
+++ b/packages/0x.js/src/0x.ts
@@ -13,13 +13,13 @@ import { TokenWrapper } from './contract_wrappers/token_wrapper';
 import { OrderStateWatcher } from './order_watcher/order_state_watcher';
 import { zeroExConfigSchema } from './schemas/zero_ex_config_schema';
 import {
-	ECSignature,
-	Order,
-	SignedOrder,
-	TransactionReceiptWithDecodedLogs,
-	Web3Provider,
-	ZeroExConfig,
-	ZeroExError,
+    ECSignature,
+    Order,
+    SignedOrder,
+    TransactionReceiptWithDecodedLogs,
+    Web3Provider,
+    ZeroExConfig,
+    ZeroExError,
 } from './types';
 import { AbiDecoder } from './utils/abi_decoder';
 import { assert } from './utils/assert';
@@ -33,318 +33,318 @@ import { utils } from './utils/utils';
  * and all calls to the library should be made through a ZeroEx instance.
  */
 export class ZeroEx {
-	/**
-	 * When creating an order without a specified taker or feeRecipient you must supply the Solidity
-	 * address null type (as opposed to Javascripts `null`, `undefined` or empty string). We expose
-	 * this constant for your convenience.
-	 */
-	public static NULL_ADDRESS = constants.NULL_ADDRESS;
+    /**
+     * When creating an order without a specified taker or feeRecipient you must supply the Solidity
+     * address null type (as opposed to Javascripts `null`, `undefined` or empty string). We expose
+     * this constant for your convenience.
+     */
+    public static NULL_ADDRESS = constants.NULL_ADDRESS;
 
-	/**
-	 * An instance of the ExchangeWrapper class containing methods for interacting with the 0x Exchange smart contract.
-	 */
-	public exchange: ExchangeWrapper;
-	/**
-	 * An instance of the TokenRegistryWrapper class containing methods for interacting with the 0x
-	 * TokenRegistry smart contract.
-	 */
-	public tokenRegistry: TokenRegistryWrapper;
-	/**
-	 * An instance of the TokenWrapper class containing methods for interacting with any ERC20 token smart contract.
-	 */
-	public token: TokenWrapper;
-	/**
-	 * An instance of the EtherTokenWrapper class containing methods for interacting with the
-	 * wrapped ETH ERC20 token smart contract.
-	 */
-	public etherToken: EtherTokenWrapper;
-	/**
-	 * An instance of the TokenTransferProxyWrapper class containing methods for interacting with the
-	 * tokenTransferProxy smart contract.
-	 */
-	public proxy: TokenTransferProxyWrapper;
-	/**
-	 * An instance of the OrderStateWatcher class containing methods for watching a set of orders for relevant
-	 * blockchain state changes.
-	 */
-	public orderStateWatcher: OrderStateWatcher;
-	private _web3Wrapper: Web3Wrapper;
-	private _abiDecoder: AbiDecoder;
-	/**
-	 * Verifies that the elliptic curve signature `signature` was generated
-	 * by signing `data` with the private key corresponding to the `signerAddress` address.
-	 * @param   data          The hex encoded data signed by the supplied signature.
-	 * @param   signature     An object containing the elliptic curve signature parameters.
-	 * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
-	 * @return  Whether the signature is valid for the supplied signerAddress and data.
-	 */
-	public static isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
-		assert.isHexString('data', data);
-		assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
-		assert.isETHAddressHex('signerAddress', signerAddress);
+    /**
+     * An instance of the ExchangeWrapper class containing methods for interacting with the 0x Exchange smart contract.
+     */
+    public exchange: ExchangeWrapper;
+    /**
+     * An instance of the TokenRegistryWrapper class containing methods for interacting with the 0x
+     * TokenRegistry smart contract.
+     */
+    public tokenRegistry: TokenRegistryWrapper;
+    /**
+     * An instance of the TokenWrapper class containing methods for interacting with any ERC20 token smart contract.
+     */
+    public token: TokenWrapper;
+    /**
+     * An instance of the EtherTokenWrapper class containing methods for interacting with the
+     * wrapped ETH ERC20 token smart contract.
+     */
+    public etherToken: EtherTokenWrapper;
+    /**
+     * An instance of the TokenTransferProxyWrapper class containing methods for interacting with the
+     * tokenTransferProxy smart contract.
+     */
+    public proxy: TokenTransferProxyWrapper;
+    /**
+     * An instance of the OrderStateWatcher class containing methods for watching a set of orders for relevant
+     * blockchain state changes.
+     */
+    public orderStateWatcher: OrderStateWatcher;
+    private _web3Wrapper: Web3Wrapper;
+    private _abiDecoder: AbiDecoder;
+    /**
+     * Verifies that the elliptic curve signature `signature` was generated
+     * by signing `data` with the private key corresponding to the `signerAddress` address.
+     * @param   data          The hex encoded data signed by the supplied signature.
+     * @param   signature     An object containing the elliptic curve signature parameters.
+     * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
+     * @return  Whether the signature is valid for the supplied signerAddress and data.
+     */
+    public static isValidSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
+        assert.isHexString('data', data);
+        assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
+        assert.isETHAddressHex('signerAddress', signerAddress);
 
-		const isValidSignature = signatureUtils.isValidSignature(data, signature, signerAddress);
-		return isValidSignature;
-	}
-	/**
-	 * Generates a pseudo-random 256-bit salt.
-	 * The salt can be included in an 0x order, ensuring that the order generates a unique orderHash
-	 * and will not collide with other outstanding orders that are identical in all other parameters.
-	 * @return  A pseudo-random 256-bit number that can be used as a salt.
-	 */
-	public static generatePseudoRandomSalt(): BigNumber {
-		// BigNumber.random returns a pseudo-random number between 0 & 1 with a passed in number of decimal places.
-		// Source: https://mikemcl.github.io/bignumber.js/#random
-		const randomNumber = BigNumber.random(constants.MAX_DIGITS_IN_UNSIGNED_256_INT);
-		const factor = new BigNumber(10).pow(constants.MAX_DIGITS_IN_UNSIGNED_256_INT - 1);
-		const salt = randomNumber.times(factor).round();
-		return salt;
-	}
-	/**
-	 * Checks if the supplied hex encoded order hash is valid.
-	 * Note: Valid means it has the expected format, not that an order with the orderHash exists.
-	 * Use this method when processing orderHashes submitted as user input.
-	 * @param   orderHash    Hex encoded orderHash.
-	 * @return  Whether the supplied orderHash has the expected format.
-	 */
-	public static isValidOrderHash(orderHash: string): boolean {
-		// Since this method can be called to check if any arbitrary string conforms to an orderHash's
-		// format, we only assert that we were indeed passed a string.
-		assert.isString('orderHash', orderHash);
-		const schemaValidator = new SchemaValidator();
-		const isValidOrderHash = schemaValidator.validate(orderHash, schemas.orderHashSchema).valid;
-		return isValidOrderHash;
-	}
-	/**
-	 * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
-	 * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
-	 * to 1 unit.
-	 * @param   amount      The amount in baseUnits that you would like converted to units.
-	 * @param   decimals    The number of decimal places the unit amount has.
-	 * @return  The amount in units.
-	 */
-	public static toUnitAmount(amount: BigNumber, decimals: number): BigNumber {
-		assert.isValidBaseUnitAmount('amount', amount);
-		assert.isNumber('decimals', decimals);
+        const isValidSignature = signatureUtils.isValidSignature(data, signature, signerAddress);
+        return isValidSignature;
+    }
+    /**
+     * Generates a pseudo-random 256-bit salt.
+     * The salt can be included in an 0x order, ensuring that the order generates a unique orderHash
+     * and will not collide with other outstanding orders that are identical in all other parameters.
+     * @return  A pseudo-random 256-bit number that can be used as a salt.
+     */
+    public static generatePseudoRandomSalt(): BigNumber {
+        // BigNumber.random returns a pseudo-random number between 0 & 1 with a passed in number of decimal places.
+        // Source: https://mikemcl.github.io/bignumber.js/#random
+        const randomNumber = BigNumber.random(constants.MAX_DIGITS_IN_UNSIGNED_256_INT);
+        const factor = new BigNumber(10).pow(constants.MAX_DIGITS_IN_UNSIGNED_256_INT - 1);
+        const salt = randomNumber.times(factor).round();
+        return salt;
+    }
+    /**
+     * Checks if the supplied hex encoded order hash is valid.
+     * Note: Valid means it has the expected format, not that an order with the orderHash exists.
+     * Use this method when processing orderHashes submitted as user input.
+     * @param   orderHash    Hex encoded orderHash.
+     * @return  Whether the supplied orderHash has the expected format.
+     */
+    public static isValidOrderHash(orderHash: string): boolean {
+        // Since this method can be called to check if any arbitrary string conforms to an orderHash's
+        // format, we only assert that we were indeed passed a string.
+        assert.isString('orderHash', orderHash);
+        const schemaValidator = new SchemaValidator();
+        const isValidOrderHash = schemaValidator.validate(orderHash, schemas.orderHashSchema).valid;
+        return isValidOrderHash;
+    }
+    /**
+     * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
+     * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
+     * to 1 unit.
+     * @param   amount      The amount in baseUnits that you would like converted to units.
+     * @param   decimals    The number of decimal places the unit amount has.
+     * @return  The amount in units.
+     */
+    public static toUnitAmount(amount: BigNumber, decimals: number): BigNumber {
+        assert.isValidBaseUnitAmount('amount', amount);
+        assert.isNumber('decimals', decimals);
 
-		const aUnit = new BigNumber(10).pow(decimals);
-		const unit = amount.div(aUnit);
-		return unit;
-	}
-	/**
-	 * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
-	 * is the amount expressed in the smallest denomination.
-	 * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
-	 * @param   amount      The amount of units that you would like converted to baseUnits.
-	 * @param   decimals    The number of decimal places the unit amount has.
-	 * @return  The amount in baseUnits.
-	 */
-	public static toBaseUnitAmount(amount: BigNumber, decimals: number): BigNumber {
-		assert.isBigNumber('amount', amount);
-		assert.isNumber('decimals', decimals);
+        const aUnit = new BigNumber(10).pow(decimals);
+        const unit = amount.div(aUnit);
+        return unit;
+    }
+    /**
+     * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
+     * is the amount expressed in the smallest denomination.
+     * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
+     * @param   amount      The amount of units that you would like converted to baseUnits.
+     * @param   decimals    The number of decimal places the unit amount has.
+     * @return  The amount in baseUnits.
+     */
+    public static toBaseUnitAmount(amount: BigNumber, decimals: number): BigNumber {
+        assert.isBigNumber('amount', amount);
+        assert.isNumber('decimals', decimals);
 
-		const unit = new BigNumber(10).pow(decimals);
-		const baseUnitAmount = amount.times(unit);
-		const hasDecimals = baseUnitAmount.decimalPlaces() !== 0;
-		if (hasDecimals) {
-			throw new Error(`Invalid unit amount: ${amount.toString()} - Too many decimal places`);
-		}
-		return baseUnitAmount;
-	}
-	/**
-	 * Computes the orderHash for a supplied order.
-	 * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
-	 * @return  The resulting orderHash from hashing the supplied order.
-	 */
-	@decorators.syncZeroExErrorHandler
-	public static getOrderHashHex(order: Order | SignedOrder): string {
-		assert.doesConformToSchema('order', order, schemas.orderSchema);
-		const orderHashHex = utils.getOrderHashHex(order);
-		return orderHashHex;
-	}
-	/**
-	 * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
-	 * @param   provider    The Web3.js Provider instance you would like the 0x.js library to use for interacting with
-	 *                      the Ethereum network.
-	 * @param   config      The configuration object. Look up the type for the description.
-	 * @return  An instance of the 0x.js ZeroEx class.
-	 */
-	constructor(provider: Web3Provider, config: ZeroExConfig) {
-		assert.isWeb3Provider('provider', provider);
-		assert.doesConformToSchema('config', config, zeroExConfigSchema);
-		const artifactJSONs = _.values(artifacts);
-		const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
-		this._abiDecoder = new AbiDecoder(abiArrays);
-		const defaults = {
-			gasPrice: config.gasPrice,
-		};
-		this._web3Wrapper = new Web3Wrapper(provider, defaults);
-		this.proxy = new TokenTransferProxyWrapper(
-			this._web3Wrapper,
-			config.networkId,
-			config.tokenTransferProxyContractAddress,
-		);
-		this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.proxy);
-		this.exchange = new ExchangeWrapper(
-			this._web3Wrapper,
-			config.networkId,
-			this._abiDecoder,
-			this.token,
-			config.exchangeContractAddress,
-			config.zrxContractAddress,
-		);
-		this.tokenRegistry = new TokenRegistryWrapper(
-			this._web3Wrapper,
-			config.networkId,
-			config.tokenRegistryContractAddress,
-		);
-		this.etherToken = new EtherTokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.token);
-		this.orderStateWatcher = new OrderStateWatcher(
-			this._web3Wrapper,
-			this._abiDecoder,
-			this.token,
-			this.exchange,
-			config.orderWatcherConfig,
-		);
-	}
-	/**
-	 * Sets a new web3 provider for 0x.js. Updating the provider will stop all
-	 * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
-	 * @param   provider    The Web3Provider you would like the 0x.js library to use from now on.
-	 * @param   networkId   The id of the network your provider is connected to
-	 */
-	public setProvider(provider: Web3Provider, networkId: number): void {
-		this._web3Wrapper.setProvider(provider);
-		(this.exchange as any)._invalidateContractInstances();
-		(this.exchange as any)._setNetworkId(networkId);
-		(this.tokenRegistry as any)._invalidateContractInstance();
-		(this.tokenRegistry as any)._setNetworkId(networkId);
-		(this.token as any)._invalidateContractInstances();
-		(this.token as any)._setNetworkId(networkId);
-		(this.proxy as any)._invalidateContractInstance();
-		(this.proxy as any)._setNetworkId(networkId);
-		(this.etherToken as any)._invalidateContractInstance();
-		(this.etherToken as any)._setNetworkId(networkId);
-	}
-	/**
-	 * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
-	 * @return  An array of available user Ethereum addresses.
-	 */
-	public async getAvailableAddressesAsync(): Promise<string[]> {
-		const availableAddresses = await this._web3Wrapper.getAvailableAddressesAsync();
-		return availableAddresses;
-	}
-	/**
-	 * Signs an orderHash and returns it's elliptic curve signature.
-	 * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
-	 * @param   orderHash       Hex encoded orderHash to sign.
-	 * @param   signerAddress   The hex encoded Ethereum address you wish to sign it with. This address
-	 *          must be available via the Web3.Provider supplied to 0x.js.
-	 * @param   shouldAddPersonalMessagePrefix  Some signers add the personal message prefix `\x19Ethereum Signed Message`
-	 *          themselves (e.g Parity Signer, Ledger, TestRPC) and others expect it to already be done by the client
-	 *          (e.g Metamask). Depending on which signer this request is going to, decide on whether to add the prefix
-	 *          before sending the request.
-	 * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
-	 */
-	public async signOrderHashAsync(
-		orderHash: string,
-		signerAddress: string,
-		shouldAddPersonalMessagePrefix: boolean,
-	): Promise<ECSignature> {
-		assert.isHexString('orderHash', orderHash);
-		await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
+        const unit = new BigNumber(10).pow(decimals);
+        const baseUnitAmount = amount.times(unit);
+        const hasDecimals = baseUnitAmount.decimalPlaces() !== 0;
+        if (hasDecimals) {
+            throw new Error(`Invalid unit amount: ${amount.toString()} - Too many decimal places`);
+        }
+        return baseUnitAmount;
+    }
+    /**
+     * Computes the orderHash for a supplied order.
+     * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
+     * @return  The resulting orderHash from hashing the supplied order.
+     */
+    @decorators.syncZeroExErrorHandler
+    public static getOrderHashHex(order: Order | SignedOrder): string {
+        assert.doesConformToSchema('order', order, schemas.orderSchema);
+        const orderHashHex = utils.getOrderHashHex(order);
+        return orderHashHex;
+    }
+    /**
+     * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
+     * @param   provider    The Web3.js Provider instance you would like the 0x.js library to use for interacting with
+     *                      the Ethereum network.
+     * @param   config      The configuration object. Look up the type for the description.
+     * @return  An instance of the 0x.js ZeroEx class.
+     */
+    constructor(provider: Web3Provider, config: ZeroExConfig) {
+        assert.isWeb3Provider('provider', provider);
+        assert.doesConformToSchema('config', config, zeroExConfigSchema);
+        const artifactJSONs = _.values(artifacts);
+        const abiArrays = _.map(artifactJSONs, artifact => artifact.abi);
+        this._abiDecoder = new AbiDecoder(abiArrays);
+        const defaults = {
+            gasPrice: config.gasPrice,
+        };
+        this._web3Wrapper = new Web3Wrapper(provider, defaults);
+        this.proxy = new TokenTransferProxyWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            config.tokenTransferProxyContractAddress,
+        );
+        this.token = new TokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.proxy);
+        this.exchange = new ExchangeWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            this._abiDecoder,
+            this.token,
+            config.exchangeContractAddress,
+            config.zrxContractAddress,
+        );
+        this.tokenRegistry = new TokenRegistryWrapper(
+            this._web3Wrapper,
+            config.networkId,
+            config.tokenRegistryContractAddress,
+        );
+        this.etherToken = new EtherTokenWrapper(this._web3Wrapper, config.networkId, this._abiDecoder, this.token);
+        this.orderStateWatcher = new OrderStateWatcher(
+            this._web3Wrapper,
+            this._abiDecoder,
+            this.token,
+            this.exchange,
+            config.orderWatcherConfig,
+        );
+    }
+    /**
+     * Sets a new web3 provider for 0x.js. Updating the provider will stop all
+     * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
+     * @param   provider    The Web3Provider you would like the 0x.js library to use from now on.
+     * @param   networkId   The id of the network your provider is connected to
+     */
+    public setProvider(provider: Web3Provider, networkId: number): void {
+        this._web3Wrapper.setProvider(provider);
+        (this.exchange as any)._invalidateContractInstances();
+        (this.exchange as any)._setNetworkId(networkId);
+        (this.tokenRegistry as any)._invalidateContractInstance();
+        (this.tokenRegistry as any)._setNetworkId(networkId);
+        (this.token as any)._invalidateContractInstances();
+        (this.token as any)._setNetworkId(networkId);
+        (this.proxy as any)._invalidateContractInstance();
+        (this.proxy as any)._setNetworkId(networkId);
+        (this.etherToken as any)._invalidateContractInstance();
+        (this.etherToken as any)._setNetworkId(networkId);
+    }
+    /**
+     * Get user Ethereum addresses available through the supplied web3 provider available for sending transactions.
+     * @return  An array of available user Ethereum addresses.
+     */
+    public async getAvailableAddressesAsync(): Promise<string[]> {
+        const availableAddresses = await this._web3Wrapper.getAvailableAddressesAsync();
+        return availableAddresses;
+    }
+    /**
+     * Signs an orderHash and returns it's elliptic curve signature.
+     * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
+     * @param   orderHash       Hex encoded orderHash to sign.
+     * @param   signerAddress   The hex encoded Ethereum address you wish to sign it with. This address
+     *          must be available via the Web3.Provider supplied to 0x.js.
+     * @param   shouldAddPersonalMessagePrefix  Some signers add the personal message prefix `\x19Ethereum Signed Message`
+     *          themselves (e.g Parity Signer, Ledger, TestRPC) and others expect it to already be done by the client
+     *          (e.g Metamask). Depending on which signer this request is going to, decide on whether to add the prefix
+     *          before sending the request.
+     * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
+     */
+    public async signOrderHashAsync(
+        orderHash: string,
+        signerAddress: string,
+        shouldAddPersonalMessagePrefix: boolean,
+    ): Promise<ECSignature> {
+        assert.isHexString('orderHash', orderHash);
+        await assert.isSenderAddressAsync('signerAddress', signerAddress, this._web3Wrapper);
 
-		let msgHashHex = orderHash;
-		if (shouldAddPersonalMessagePrefix) {
-			const orderHashBuff = ethUtil.toBuffer(orderHash);
-			const msgHashBuff = ethUtil.hashPersonalMessage(orderHashBuff);
-			msgHashHex = ethUtil.bufferToHex(msgHashBuff);
-		}
+        let msgHashHex = orderHash;
+        if (shouldAddPersonalMessagePrefix) {
+            const orderHashBuff = ethUtil.toBuffer(orderHash);
+            const msgHashBuff = ethUtil.hashPersonalMessage(orderHashBuff);
+            msgHashHex = ethUtil.bufferToHex(msgHashBuff);
+        }
 
-		const signature = await this._web3Wrapper.signTransactionAsync(signerAddress, msgHashHex);
+        const signature = await this._web3Wrapper.signTransactionAsync(signerAddress, msgHashHex);
 
-		// HACK: There is no consensus on whether the signatureHex string should be formatted as
-		// v + r + s OR r + s + v, and different clients (even different versions of the same client)
-		// return the signature params in different orders. In order to support all client implementations,
-		// we parse the signature in both ways, and evaluate if either one is a valid signature.
-		const validVParamValues = [27, 28];
-		const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
-		if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-			const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, signerAddress);
-			if (isValidVRSSignature) {
-				return ecSignatureVRS;
-			}
-		}
+        // HACK: There is no consensus on whether the signatureHex string should be formatted as
+        // v + r + s OR r + s + v, and different clients (even different versions of the same client)
+        // return the signature params in different orders. In order to support all client implementations,
+        // we parse the signature in both ways, and evaluate if either one is a valid signature.
+        const validVParamValues = [27, 28];
+        const ecSignatureVRS = signatureUtils.parseSignatureHexAsVRS(signature);
+        if (_.includes(validVParamValues, ecSignatureVRS.v)) {
+            const isValidVRSSignature = ZeroEx.isValidSignature(orderHash, ecSignatureVRS, signerAddress);
+            if (isValidVRSSignature) {
+                return ecSignatureVRS;
+            }
+        }
 
-		const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
-		if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-			const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, signerAddress);
-			if (isValidRSVSignature) {
-				return ecSignatureRSV;
-			}
-		}
+        const ecSignatureRSV = signatureUtils.parseSignatureHexAsRSV(signature);
+        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
+            const isValidRSVSignature = ZeroEx.isValidSignature(orderHash, ecSignatureRSV, signerAddress);
+            if (isValidRSVSignature) {
+                return ecSignatureRSV;
+            }
+        }
 
-		throw new Error(ZeroExError.InvalidSignature);
-	}
-	/**
-	 * Waits for a transaction to be mined and returns the transaction receipt.
-	 * @param   txHash            Transaction hash
-	 * @param   pollingIntervalMs How often (in ms) should we check if the transaction is mined.
-	 * @param   timeoutMs         How long (in ms) to poll for transaction mined until aborting.
-	 * @return  Transaction receipt with decoded log args.
-	 */
-	public async awaitTransactionMinedAsync(
-		txHash: string,
-		pollingIntervalMs = 1000,
-		timeoutMs?: number,
-	): Promise<TransactionReceiptWithDecodedLogs> {
-		let timeoutExceeded = false;
-		if (timeoutMs) {
-			setTimeout(() => (timeoutExceeded = true), timeoutMs);
-		}
+        throw new Error(ZeroExError.InvalidSignature);
+    }
+    /**
+     * Waits for a transaction to be mined and returns the transaction receipt.
+     * @param   txHash            Transaction hash
+     * @param   pollingIntervalMs How often (in ms) should we check if the transaction is mined.
+     * @param   timeoutMs         How long (in ms) to poll for transaction mined until aborting.
+     * @return  Transaction receipt with decoded log args.
+     */
+    public async awaitTransactionMinedAsync(
+        txHash: string,
+        pollingIntervalMs = 1000,
+        timeoutMs?: number,
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        let timeoutExceeded = false;
+        if (timeoutMs) {
+            setTimeout(() => (timeoutExceeded = true), timeoutMs);
+        }
 
-		const txReceiptPromise = new Promise(
-			(resolve: (receipt: TransactionReceiptWithDecodedLogs) => void, reject) => {
-				const intervalId = intervalUtils.setAsyncExcludingInterval(
-					async () => {
-						if (timeoutExceeded) {
-							intervalUtils.clearAsyncExcludingInterval(intervalId);
-							return reject(ZeroExError.TransactionMiningTimeout);
-						}
+        const txReceiptPromise = new Promise(
+            (resolve: (receipt: TransactionReceiptWithDecodedLogs) => void, reject) => {
+                const intervalId = intervalUtils.setAsyncExcludingInterval(
+                    async () => {
+                        if (timeoutExceeded) {
+                            intervalUtils.clearAsyncExcludingInterval(intervalId);
+                            return reject(ZeroExError.TransactionMiningTimeout);
+                        }
 
-						const transactionReceipt = await this._web3Wrapper.getTransactionReceiptAsync(txHash);
-						if (!_.isNull(transactionReceipt)) {
-							intervalUtils.clearAsyncExcludingInterval(intervalId);
-							const logsWithDecodedArgs = _.map(
-								transactionReceipt.logs,
-								this._abiDecoder.tryToDecodeLogOrNoop.bind(this._abiDecoder),
-							);
-							const transactionReceiptWithDecodedLogArgs: TransactionReceiptWithDecodedLogs = {
-								...transactionReceipt,
-								logs: logsWithDecodedArgs,
-							};
-							resolve(transactionReceiptWithDecodedLogArgs);
-						}
-					},
-					pollingIntervalMs,
-					(err: Error) => {
-						intervalUtils.clearAsyncExcludingInterval(intervalId);
-						reject(err);
-					},
-				);
-			},
-		);
+                        const transactionReceipt = await this._web3Wrapper.getTransactionReceiptAsync(txHash);
+                        if (!_.isNull(transactionReceipt)) {
+                            intervalUtils.clearAsyncExcludingInterval(intervalId);
+                            const logsWithDecodedArgs = _.map(
+                                transactionReceipt.logs,
+                                this._abiDecoder.tryToDecodeLogOrNoop.bind(this._abiDecoder),
+                            );
+                            const transactionReceiptWithDecodedLogArgs: TransactionReceiptWithDecodedLogs = {
+                                ...transactionReceipt,
+                                logs: logsWithDecodedArgs,
+                            };
+                            resolve(transactionReceiptWithDecodedLogArgs);
+                        }
+                    },
+                    pollingIntervalMs,
+                    (err: Error) => {
+                        intervalUtils.clearAsyncExcludingInterval(intervalId);
+                        reject(err);
+                    },
+                );
+            },
+        );
 
-		return txReceiptPromise;
-	}
-	/*
+        return txReceiptPromise;
+    }
+    /*
      * HACK: `TokenWrapper` needs a token transfer proxy address. `TokenTransferProxy` address is fetched from
      * an `ExchangeWrapper`. `ExchangeWrapper` needs `TokenWrapper` to validate orders, creating a dependency cycle.
      * In order to break this - we create this function here and pass it as a parameter to the `TokenWrapper`
      * and `ProxyWrapper`.
      */
-	private async _getTokenTransferProxyAddressAsync(): Promise<string> {
-		const tokenTransferProxyAddress = await (this.exchange as any)._getTokenTransferProxyAddressAsync();
-		return tokenTransferProxyAddress;
-	}
+    private async _getTokenTransferProxyAddressAsync(): Promise<string> {
+        const tokenTransferProxyAddress = await (this.exchange as any)._getTokenTransferProxyAddressAsync();
+        return tokenTransferProxyAddress;
+    }
 }