Make signature_util into an object literal so related functions are rendered together in the docs

4 files changed, 299 insertions, 285 deletions

diff --git a/packages/order-utils/src/index.ts b/packages/order-utils/src/index.ts
index da53f620a..5852a01b9 100644
--- a/packages/order-utils/src/index.ts
+++ b/packages/order-utils/src/index.ts
@@ -1,15 +1,5 @@
 export { orderHashUtils } from './order_hash';
-export {
-    isValidSignatureAsync,
-    isValidPresignedSignatureAsync,
-    isValidWalletSignatureAsync,
-    isValidValidatorSignatureAsync,
-    isValidECSignature,
-    ecSignOrderHashAsync,
-    addSignedMessagePrefix,
-    parseECSignature,
-} from './signature_utils';
-export { orderFactory } from './order_factory';
+export { signatureUtils } from './signature_utils';
 export { constants } from './constants';
 export { crypto } from './crypto';
 export { generatePseudoRandomSalt } from './salt';
diff --git a/packages/order-utils/src/order_factory.ts b/packages/order-utils/src/order_factory.ts
index 803cb82b1..14122f353 100644
--- a/packages/order-utils/src/order_factory.ts
+++ b/packages/order-utils/src/order_factory.ts
@@ -6,7 +6,7 @@ import * as _ from 'lodash';
 
 import { orderHashUtils } from './order_hash';
 import { generatePseudoRandomSalt } from './salt';
-import { ecSignOrderHashAsync } from './signature_utils';
+import { signatureUtils } from './signature_utils';
 import { MessagePrefixType } from './types';
 
 export const orderFactory = {
@@ -49,7 +49,12 @@ export const orderFactory = {
             prefixType: MessagePrefixType.EthSign,
             shouldAddPrefixBeforeCallingEthSign: false,
         };
-        const ecSignature = await ecSignOrderHashAsync(provider, orderHash, makerAddress, messagePrefixOpts);
+        const ecSignature = await signatureUtils.ecSignOrderHashAsync(
+            provider,
+            orderHash,
+            makerAddress,
+            messagePrefixOpts,
+        );
         const signature = getVRSHexString(ecSignature);
         const signedOrder: SignedOrder = _.assign(order, { signature });
         return signedOrder;
diff --git a/packages/order-utils/src/order_validation_utils.ts b/packages/order-utils/src/order_validation_utils.ts
index 67d747081..ccc6e653f 100644
--- a/packages/order-utils/src/order_validation_utils.ts
+++ b/packages/order-utils/src/order_validation_utils.ts
@@ -9,7 +9,7 @@ import { AbstractOrderFilledCancelledFetcher } from './abstract/abstract_order_f
 import { constants } from './constants';
 import { ExchangeTransferSimulator } from './exchange_transfer_simulator';
 import { orderHashUtils } from './order_hash';
-import { isValidSignatureAsync } from './signature_utils';
+import { signatureUtils } from './signature_utils';
 import { utils } from './utils';
 
 export class OrderValidationUtils {
@@ -147,7 +147,7 @@ export class OrderValidationUtils {
             throw new Error(RevertReason.InvalidTakerAmount);
         }
         const orderHash = orderHashUtils.getOrderHashHex(signedOrder);
-        const isValid = await isValidSignatureAsync(
+        const isValid = await signatureUtils.isValidSignatureAsync(
             provider,
             orderHash,
             signedOrder.signature,
diff --git a/packages/order-utils/src/signature_utils.ts b/packages/order-utils/src/signature_utils.ts
index 26fb24705..2dc465256 100644
--- a/packages/order-utils/src/signature_utils.ts
+++ b/packages/order-utils/src/signature_utils.ts
@@ -13,288 +13,307 @@ import { IWalletContract } from './generated_contract_wrappers/i_wallet';
 import { MessagePrefixOpts, MessagePrefixType, OrderError } from './types';
 import { utils } from './utils';
 
-/**
- * Verifies that the provided signature is valid according to the 0x Protocol smart contracts
- * @param   data          The hex encoded data signed by the supplied signature.
- * @param   signature     A hex encoded 0x Protocol signature made up of: [TypeSpecificData][SignatureType].
- *          E.g [vrs][SignatureType.EIP712]
- * @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.
- */
-export async function isValidSignatureAsync(
-    provider: Provider,
-    data: string,
-    signature: string,
-    signerAddress: string,
-): Promise<boolean> {
-    assert.isWeb3Provider('provider', provider);
-    assert.isHexString('data', data);
-    assert.isHexString('signature', signature);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-    const signatureTypeIndexIfExists = utils.getSignatureTypeIndexIfExists(signature);
-    if (_.isUndefined(signatureTypeIndexIfExists)) {
-        throw new Error(`Unrecognized signatureType in signature: ${signature}`);
-    }
-
-    switch (signatureTypeIndexIfExists) {
-        case SignatureType.Illegal:
-        case SignatureType.Invalid:
-            return false;
-
-        case SignatureType.EIP712: {
-            const ecSignature = parseECSignature(signature);
-            return isValidECSignature(data, ecSignature, signerAddress);
-        }
-
-        case SignatureType.EthSign: {
-            const ecSignature = parseECSignature(signature);
-            const prefixedMessageHex = addSignedMessagePrefix(data, MessagePrefixType.EthSign);
-            return isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
+export const signatureUtils = {
+    /**
+     * Verifies that the provided signature is valid according to the 0x Protocol smart contracts
+     * @param   provider      Web3 provider to use for all JSON RPC requests
+     * @param   data          The hex encoded data signed by the supplied signature.
+     * @param   signature     A hex encoded 0x Protocol signature made up of: [TypeSpecificData][SignatureType].
+     *          E.g [vrs][SignatureType.EIP712]
+     * @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.
+     */
+    async isValidSignatureAsync(
+        provider: Provider,
+        data: string,
+        signature: string,
+        signerAddress: string,
+    ): Promise<boolean> {
+        assert.isWeb3Provider('provider', provider);
+        assert.isHexString('data', data);
+        assert.isHexString('signature', signature);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+        const signatureTypeIndexIfExists = utils.getSignatureTypeIndexIfExists(signature);
+        if (_.isUndefined(signatureTypeIndexIfExists)) {
+            throw new Error(`Unrecognized signatureType in signature: ${signature}`);
         }
 
-        case SignatureType.Caller:
-            // HACK: We currently do not "validate" the caller signature type.
-            // It can only be validated during Exchange contract execution.
-            throw new Error('Caller signature type cannot be validated off-chain');
-
-        case SignatureType.Wallet: {
-            const isValid = await isValidWalletSignatureAsync(provider, data, signature, signerAddress);
-            return isValid;
-        }
-
-        case SignatureType.Validator: {
-            const isValid = await isValidValidatorSignatureAsync(provider, data, signature, signerAddress);
-            return isValid;
+        switch (signatureTypeIndexIfExists) {
+            case SignatureType.Illegal:
+            case SignatureType.Invalid:
+                return false;
+
+            case SignatureType.EIP712: {
+                const ecSignature = signatureUtils.parseECSignature(signature);
+                return signatureUtils.isValidECSignature(data, ecSignature, signerAddress);
+            }
+
+            case SignatureType.EthSign: {
+                const ecSignature = signatureUtils.parseECSignature(signature);
+                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, MessagePrefixType.EthSign);
+                return signatureUtils.isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
+            }
+
+            case SignatureType.Caller:
+                // HACK: We currently do not "validate" the caller signature type.
+                // It can only be validated during Exchange contract execution.
+                throw new Error('Caller signature type cannot be validated off-chain');
+
+            case SignatureType.Wallet: {
+                const isValid = await signatureUtils.isValidWalletSignatureAsync(
+                    provider,
+                    data,
+                    signature,
+                    signerAddress,
+                );
+                return isValid;
+            }
+
+            case SignatureType.Validator: {
+                const isValid = await signatureUtils.isValidValidatorSignatureAsync(
+                    provider,
+                    data,
+                    signature,
+                    signerAddress,
+                );
+                return isValid;
+            }
+
+            case SignatureType.PreSigned: {
+                return signatureUtils.isValidPresignedSignatureAsync(provider, data, signerAddress);
+            }
+
+            case SignatureType.Trezor: {
+                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, MessagePrefixType.Trezor);
+                const ecSignature = signatureUtils.parseECSignature(signature);
+                return signatureUtils.isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
+            }
+
+            default:
+                throw new Error(`Unhandled SignatureType: ${signatureTypeIndexIfExists}`);
         }
-
-        case SignatureType.PreSigned: {
-            return isValidPresignedSignatureAsync(provider, data, signerAddress);
-        }
-
-        case SignatureType.Trezor: {
-            const prefixedMessageHex = addSignedMessagePrefix(data, MessagePrefixType.Trezor);
-            const ecSignature = parseECSignature(signature);
-            return isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
+    },
+    /**
+     * Verifies that the provided presigned signature is valid according to the 0x Protocol smart contracts
+     * @param   provider      Web3 provider to use for all JSON RPC requests
+     * @param   data          The hex encoded data signed by the supplied signature
+     * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
+     * @return  Whether the data was preSigned by the supplied signerAddress
+     */
+    async isValidPresignedSignatureAsync(provider: Provider, data: string, signerAddress: string): Promise<boolean> {
+        assert.isWeb3Provider('provider', provider);
+        assert.isHexString('data', data);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+        const exchangeContract = new ExchangeContract(artifacts.Exchange.compilerOutput.abi, signerAddress, provider);
+        const isValid = await exchangeContract.preSigned.callAsync(data, signerAddress);
+        return isValid;
+    },
+    /**
+     * Verifies that the provided wallet signature is valid according to the 0x Protocol smart contracts
+     * @param   provider      Web3 provider to use for all JSON RPC requests
+     * @param   data          The hex encoded data signed by the supplied signature.
+     * @param   signature     A hex encoded presigned 0x Protocol signature made up of: [SignatureType.Presigned]
+     * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
+     * @return  Whether the data was preSigned by the supplied signerAddress.
+     */
+    async isValidWalletSignatureAsync(
+        provider: Provider,
+        data: string,
+        signature: string,
+        signerAddress: string,
+    ): Promise<boolean> {
+        assert.isWeb3Provider('provider', provider);
+        assert.isHexString('data', data);
+        assert.isHexString('signature', signature);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+        // tslint:disable-next-line:custom-no-magic-numbers
+        const signatureWithoutType = signature.slice(-2);
+        const walletContract = new IWalletContract(artifacts.IWallet.compilerOutput.abi, signerAddress, provider);
+        const isValid = await walletContract.isValidSignature.callAsync(data, signatureWithoutType);
+        return isValid;
+    },
+    /**
+     * Verifies that the provided validator signature is valid according to the 0x Protocol smart contracts
+     * @param   provider      Web3 provider to use for all JSON RPC requests
+     * @param   data          The hex encoded data signed by the supplied signature.
+     * @param   signature     A hex encoded presigned 0x Protocol signature made up of: [SignatureType.Presigned]
+     * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
+     * @return  Whether the data was preSigned by the supplied signerAddress.
+     */
+    async isValidValidatorSignatureAsync(
+        provider: Provider,
+        data: string,
+        signature: string,
+        signerAddress: string,
+    ): Promise<boolean> {
+        assert.isWeb3Provider('provider', provider);
+        assert.isHexString('data', data);
+        assert.isHexString('signature', signature);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+        const validatorSignature = parseValidatorSignature(signature);
+        const exchangeContract = new ExchangeContract(artifacts.Exchange.compilerOutput.abi, signerAddress, provider);
+        const isValidatorApproved = await exchangeContract.allowedValidators.callAsync(
+            signerAddress,
+            validatorSignature.validatorAddress,
+        );
+        if (!isValidatorApproved) {
+            throw new Error(
+                `Validator ${validatorSignature.validatorAddress} was not pre-approved by ${signerAddress}.`,
+            );
         }
 
-        default:
-            throw new Error(`Unhandled SignatureType: ${signatureTypeIndexIfExists}`);
-    }
-}
-
-/**
- * Verifies that the provided presigned signature is valid according to the 0x Protocol smart contracts
- * @param   data          The hex encoded data signed by the supplied signature.
- * @param   signature     A hex encoded presigned 0x Protocol signature made up of: [SignatureType.Presigned]
- * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
- * @return  Whether the data was preSigned by the supplied signerAddress.
- */
-export async function isValidPresignedSignatureAsync(
-    provider: Provider,
-    data: string,
-    signerAddress: string,
-): Promise<boolean> {
-    assert.isWeb3Provider('provider', provider);
-    assert.isHexString('data', data);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-    const exchangeContract = new ExchangeContract(artifacts.Exchange.compilerOutput.abi, signerAddress, provider);
-    const isValid = await exchangeContract.preSigned.callAsync(data, signerAddress);
-    return isValid;
-}
-
-/**
- * Verifies that the provided wallet signature is valid according to the 0x Protocol smart contracts
- * @param   data          The hex encoded data signed by the supplied signature.
- * @param   signature     A hex encoded presigned 0x Protocol signature made up of: [SignatureType.Presigned]
- * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
- * @return  Whether the data was preSigned by the supplied signerAddress.
- */
-export async function isValidWalletSignatureAsync(
-    provider: Provider,
-    data: string,
-    signature: string,
-    signerAddress: string,
-): Promise<boolean> {
-    assert.isWeb3Provider('provider', provider);
-    assert.isHexString('data', data);
-    assert.isHexString('signature', signature);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-    // tslint:disable-next-line:custom-no-magic-numbers
-    const signatureWithoutType = signature.slice(-2);
-    const walletContract = new IWalletContract(artifacts.IWallet.compilerOutput.abi, signerAddress, provider);
-    const isValid = await walletContract.isValidSignature.callAsync(data, signatureWithoutType);
-    return isValid;
-}
-
-/**
- * Verifies that the provided validator signature is valid according to the 0x Protocol smart contracts
- * @param   data          The hex encoded data signed by the supplied signature.
- * @param   signature     A hex encoded presigned 0x Protocol signature made up of: [SignatureType.Presigned]
- * @param   signerAddress The hex encoded address that signed the data, producing the supplied signature.
- * @return  Whether the data was preSigned by the supplied signerAddress.
- */
-export async function isValidValidatorSignatureAsync(
-    provider: Provider,
-    data: string,
-    signature: string,
-    signerAddress: string,
-): Promise<boolean> {
-    assert.isWeb3Provider('provider', provider);
-    assert.isHexString('data', data);
-    assert.isHexString('signature', signature);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-    const validatorSignature = parseValidatorSignature(signature);
-    const exchangeContract = new ExchangeContract(artifacts.Exchange.compilerOutput.abi, signerAddress, provider);
-    const isValidatorApproved = await exchangeContract.allowedValidators.callAsync(
-        signerAddress,
-        validatorSignature.validatorAddress,
-    );
-    if (!isValidatorApproved) {
-        throw new Error(`Validator ${validatorSignature.validatorAddress} was not pre-approved by ${signerAddress}.`);
-    }
-
-    const validatorContract = new IValidatorContract(artifacts.IValidator.compilerOutput.abi, signerAddress, provider);
-    const isValid = await validatorContract.isValidSignature.callAsync(
-        data,
-        signerAddress,
-        validatorSignature.signature,
-    );
-    return isValid;
-}
-
-/**
- * Checks if the supplied elliptic curve signature corresponds to signing `data` with
- * the private key corresponding to `signerAddress`
- * @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 ECSignature is valid.
- */
-export function isValidECSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
-    assert.isHexString('data', data);
-    assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-
-    const msgHashBuff = ethUtil.toBuffer(data);
-    try {
-        const pubKey = ethUtil.ecrecover(
-            msgHashBuff,
-            signature.v,
-            ethUtil.toBuffer(signature.r),
-            ethUtil.toBuffer(signature.s),
+        const validatorContract = new IValidatorContract(
+            artifacts.IValidator.compilerOutput.abi,
+            signerAddress,
+            provider,
         );
-        const retrievedAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
-        return retrievedAddress === signerAddress;
-    } catch (err) {
-        return false;
-    }
-}
-
-/**
- * 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 Provider supplied to 0x.js.
- * @param   hashPrefixOpts Different signers add/require different prefixes be appended to the message being signed.
- *          Since we cannot know ahead of time which signer you are using, you must supply both a prefixType and
- *          whether it must be added before calling `eth_sign` (some signers add it themselves)
- * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
- */
-export async function ecSignOrderHashAsync(
-    provider: Provider,
-    orderHash: string,
-    signerAddress: string,
-    messagePrefixOpts: MessagePrefixOpts,
-): Promise<ECSignature> {
-    assert.isWeb3Provider('provider', provider);
-    assert.isHexString('orderHash', orderHash);
-    assert.isETHAddressHex('signerAddress', signerAddress);
-    const web3Wrapper = new Web3Wrapper(provider);
-    await assert.isSenderAddressAsync('signerAddress', signerAddress, web3Wrapper);
-    const normalizedSignerAddress = signerAddress.toLowerCase();
-
-    let msgHashHex = orderHash;
-    const prefixedMsgHashHex = addSignedMessagePrefix(orderHash, messagePrefixOpts.prefixType);
-    if (messagePrefixOpts.shouldAddPrefixBeforeCallingEthSign) {
-        msgHashHex = prefixedMsgHashHex;
-    }
-    const signature = await web3Wrapper.signMessageAsync(normalizedSignerAddress, 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.
-    // tslint:disable-next-line:custom-no-magic-numbers
-    const validVParamValues = [27, 28];
-    const ecSignatureVRS = parseSignatureHexAsVRS(signature);
-    if (_.includes(validVParamValues, ecSignatureVRS.v)) {
-        const isValidVRSSignature = isValidECSignature(prefixedMsgHashHex, ecSignatureVRS, normalizedSignerAddress);
-        if (isValidVRSSignature) {
-            return ecSignatureVRS;
+        const isValid = await validatorContract.isValidSignature.callAsync(
+            data,
+            signerAddress,
+            validatorSignature.signature,
+        );
+        return isValid;
+    },
+    /**
+     * Checks if the supplied elliptic curve signature corresponds to signing `data` with
+     * the private key corresponding to `signerAddress`
+     * @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 ECSignature is valid.
+     */
+    isValidECSignature(data: string, signature: ECSignature, signerAddress: string): boolean {
+        assert.isHexString('data', data);
+        assert.doesConformToSchema('signature', signature, schemas.ecSignatureSchema);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+
+        const msgHashBuff = ethUtil.toBuffer(data);
+        try {
+            const pubKey = ethUtil.ecrecover(
+                msgHashBuff,
+                signature.v,
+                ethUtil.toBuffer(signature.r),
+                ethUtil.toBuffer(signature.s),
+            );
+            const retrievedAddress = ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));
+            return retrievedAddress === signerAddress;
+        } catch (err) {
+            return false;
         }
-    }
-
-    const ecSignatureRSV = parseSignatureHexAsRSV(signature);
-    if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-        const isValidRSVSignature = isValidECSignature(prefixedMsgHashHex, ecSignatureRSV, normalizedSignerAddress);
-        if (isValidRSVSignature) {
-            return ecSignatureRSV;
+    },
+    /**
+     * 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   provider The provider to use for JSON RPC calls
+     * @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 Provider supplied to 0x.js.
+     * @param   messagePrefixOpts Different signers add/require different prefixes be appended to the message being signed.
+     *          Since we cannot know ahead of time which signer you are using, you must supply both a prefixType and
+     *          whether it must be added before calling `eth_sign` (some signers add it themselves)
+     * @return  An object containing the Elliptic curve signature parameters generated by signing the orderHash.
+     */
+    async ecSignOrderHashAsync(
+        provider: Provider,
+        orderHash: string,
+        signerAddress: string,
+        messagePrefixOpts: MessagePrefixOpts,
+    ): Promise<ECSignature> {
+        assert.isWeb3Provider('provider', provider);
+        assert.isHexString('orderHash', orderHash);
+        assert.isETHAddressHex('signerAddress', signerAddress);
+        const web3Wrapper = new Web3Wrapper(provider);
+        await assert.isSenderAddressAsync('signerAddress', signerAddress, web3Wrapper);
+        const normalizedSignerAddress = signerAddress.toLowerCase();
+
+        let msgHashHex = orderHash;
+        const prefixedMsgHashHex = signatureUtils.addSignedMessagePrefix(orderHash, messagePrefixOpts.prefixType);
+        if (messagePrefixOpts.shouldAddPrefixBeforeCallingEthSign) {
+            msgHashHex = prefixedMsgHashHex;
         }
-    }
-
-    throw new Error(OrderError.InvalidSignature);
-}
-
-/**
- * Adds the relevant prefix to the message being signed.
- * @param message Message to sign
- * @param messagePrefixType The type of message prefix to add. Different signers expect
- *                          specific message prefixes.
- * @return Prefixed message
- */
-export function addSignedMessagePrefix(message: string, messagePrefixType: MessagePrefixType): string {
-    assert.isString('message', message);
-    assert.doesBelongToStringEnum('messagePrefixType', messagePrefixType, MessagePrefixType);
-    switch (messagePrefixType) {
-        case MessagePrefixType.None:
-            return message;
-
-        case MessagePrefixType.EthSign: {
-            const msgBuff = ethUtil.toBuffer(message);
-            const prefixedMsgBuff = ethUtil.hashPersonalMessage(msgBuff);
-            const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
-            return prefixedMsgHex;
+        const signature = await web3Wrapper.signMessageAsync(normalizedSignerAddress, 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.
+        // tslint:disable-next-line:custom-no-magic-numbers
+        const validVParamValues = [27, 28];
+        const ecSignatureVRS = parseSignatureHexAsVRS(signature);
+        if (_.includes(validVParamValues, ecSignatureVRS.v)) {
+            const isValidVRSSignature = signatureUtils.isValidECSignature(
+                prefixedMsgHashHex,
+                ecSignatureVRS,
+                normalizedSignerAddress,
+            );
+            if (isValidVRSSignature) {
+                return ecSignatureVRS;
+            }
         }
 
-        case MessagePrefixType.Trezor: {
-            const msgBuff = ethUtil.toBuffer(message);
-            const prefixedMsgBuff = hashTrezorPersonalMessage(msgBuff);
-            const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
-            return prefixedMsgHex;
+        const ecSignatureRSV = parseSignatureHexAsRSV(signature);
+        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
+            const isValidRSVSignature = signatureUtils.isValidECSignature(
+                prefixedMsgHashHex,
+                ecSignatureRSV,
+                normalizedSignerAddress,
+            );
+            if (isValidRSVSignature) {
+                return ecSignatureRSV;
+            }
         }
 
-        default:
-            throw new Error(`Unrecognized MessagePrefixType: ${messagePrefixType}`);
-    }
-}
-
-/**
- * Parse a 0x protocol hex-encoded signature string into it's ECSignature components
- * @param signature A hex encoded ecSignature 0x Protocol signature
- * @return An ECSignature object with r,s,v parameters
- */
-export function parseECSignature(signature: string): ECSignature {
-    assert.isHexString('signature', signature);
-    const ecSignatureTypes = [SignatureType.EthSign, SignatureType.EIP712, SignatureType.Trezor];
-    assert.isOneOfExpectedSignatureTypes(signature, ecSignatureTypes);
-
-    // tslint:disable-next-line:custom-no-magic-numbers
-    const vrsHex = signature.slice(0, -2);
-    const ecSignature = parseSignatureHexAsVRS(vrsHex);
-
-    return ecSignature;
-}
+        throw new Error(OrderError.InvalidSignature);
+    },
+    /**
+     * Adds the relevant prefix to the message being signed.
+     * @param message Message to sign
+     * @param messagePrefixType The type of message prefix to add. Different signers expect
+     *                          specific message prefixes.
+     * @return Prefixed message
+     */
+    addSignedMessagePrefix(message: string, messagePrefixType: MessagePrefixType): string {
+        assert.isString('message', message);
+        assert.doesBelongToStringEnum('messagePrefixType', messagePrefixType, MessagePrefixType);
+        switch (messagePrefixType) {
+            case MessagePrefixType.None:
+                return message;
+
+            case MessagePrefixType.EthSign: {
+                const msgBuff = ethUtil.toBuffer(message);
+                const prefixedMsgBuff = ethUtil.hashPersonalMessage(msgBuff);
+                const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
+                return prefixedMsgHex;
+            }
+
+            case MessagePrefixType.Trezor: {
+                const msgBuff = ethUtil.toBuffer(message);
+                const prefixedMsgBuff = hashTrezorPersonalMessage(msgBuff);
+                const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
+                return prefixedMsgHex;
+            }
+
+            default:
+                throw new Error(`Unrecognized MessagePrefixType: ${messagePrefixType}`);
+        }
+    },
+    /**
+     * Parse a 0x protocol hex-encoded signature string into it's ECSignature components
+     * @param signature A hex encoded ecSignature 0x Protocol signature
+     * @return An ECSignature object with r,s,v parameters
+     */
+    parseECSignature(signature: string): ECSignature {
+        assert.isHexString('signature', signature);
+        const ecSignatureTypes = [SignatureType.EthSign, SignatureType.EIP712, SignatureType.Trezor];
+        assert.isOneOfExpectedSignatureTypes(signature, ecSignatureTypes);
+
+        // tslint:disable-next-line:custom-no-magic-numbers
+        const vrsHex = signature.slice(0, -2);
+        const ecSignature = parseSignatureHexAsVRS(vrsHex);
+
+        return ecSignature;
+    },
+};
 
 function hashTrezorPersonalMessage(message: Buffer): Buffer {
     const prefix = ethUtil.toBuffer('\x19Ethereum Signed Message:\n' + String.fromCharCode(message.byteLength));