Merge development

6 files changed, 293 insertions, 106 deletions

diff --git a/packages/order-utils/src/constants.ts b/packages/order-utils/src/constants.ts
index bb7482184..c23578c20 100644
--- a/packages/order-utils/src/constants.ts
+++ b/packages/order-utils/src/constants.ts
@@ -2,6 +2,7 @@ import { BigNumber } from '@0xproject/utils';
 
 export const constants = {
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
+    NULL_BYTES: '0x',
     // tslint:disable-next-line:custom-no-magic-numbers
     UNLIMITED_ALLOWANCE_IN_BASE_UNITS: new BigNumber(2).pow(256).minus(1),
     TESTRPC_NETWORK_ID: 50,
@@ -10,4 +11,6 @@ export const constants = {
     ERC721_ASSET_DATA_MINIMUM_BYTE_LENGTH: 53,
     SELECTOR_LENGTH: 4,
     BASE_16: 16,
+    INFINITE_TIMESTAMP_SEC: new BigNumber(2524604400), // Close to infinite
+    ZERO_AMOUNT: new BigNumber(0),
 };
diff --git a/packages/order-utils/src/index.ts b/packages/order-utils/src/index.ts
index f3b00a583..638126af6 100644
--- a/packages/order-utils/src/index.ts
+++ b/packages/order-utils/src/index.ts
@@ -3,6 +3,7 @@ export { signatureUtils } from './signature_utils';
 export { generatePseudoRandomSalt } from './salt';
 export { assetDataUtils } from './asset_data_utils';
 export { eip712Utils } from './eip712_utils';
+export { marketUtils } from './market_utils';
 
 export { OrderStateUtils } from './order_state_utils';
 export { AbstractBalanceAndProxyAllowanceFetcher } from './abstract/abstract_balance_and_proxy_allowance_fetcher';
@@ -25,9 +26,8 @@ export {
     AssetProxyId,
 } from '@0xproject/types';
 export {
+    CreateOrderOpts,
     OrderError,
-    MessagePrefixType,
-    MessagePrefixOpts,
     EIP712Parameter,
     EIP712Schema,
     EIP712Types,
diff --git a/packages/order-utils/src/market_utils.ts b/packages/order-utils/src/market_utils.ts
new file mode 100644
index 000000000..681059ddf
--- /dev/null
+++ b/packages/order-utils/src/market_utils.ts
@@ -0,0 +1,133 @@
+import { schemas } from '@0xproject/json-schemas';
+import { SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import * as _ from 'lodash';
+
+import { assert } from './assert';
+import { constants } from './constants';
+
+export const marketUtils = {
+    /**
+     * Takes an array of orders and returns a subset of those orders that has enough makerAssetAmount (taking into account on-chain balances,
+     * allowances, and partial fills) in order to fill the input makerAssetFillAmount plus slippageBufferAmount. Iterates from first order to last.
+     * Sort the input by ascending rate in order to get the subset of orders that will cost the least ETH.
+     * @param   signedOrders                        An array of objects that conform to the SignedOrder interface. All orders should specify the same makerAsset.
+     *                                              All orders should specify WETH as the takerAsset.
+     * @param   remainingFillableMakerAssetAmounts  An array of BigNumbers corresponding to the signedOrders parameter.
+     *                                              You can use OrderStateUtils @0xproject/order-utils to perform blockchain lookups
+     *                                              for these values.
+     * @param   makerAssetFillAmount                The amount of makerAsset desired to be filled.
+     * @param   slippageBufferAmount                An additional amount of makerAsset to be covered by the result in case of trade collisions or partial fills.
+     * @return  Resulting orders and remaining fill amount that could not be covered by the input.
+     */
+    findOrdersThatCoverMakerAssetFillAmount(
+        signedOrders: SignedOrder[],
+        remainingFillableMakerAssetAmounts: BigNumber[],
+        makerAssetFillAmount: BigNumber,
+        slippageBufferAmount: BigNumber = constants.ZERO_AMOUNT,
+    ): { resultOrders: SignedOrder[]; remainingFillAmount: BigNumber } {
+        assert.doesConformToSchema('signedOrders', signedOrders, schemas.signedOrdersSchema);
+        _.forEach(remainingFillableMakerAssetAmounts, (amount, index) =>
+            assert.isValidBaseUnitAmount(`remainingFillableMakerAssetAmount[${index}]`, amount),
+        );
+        assert.isValidBaseUnitAmount('makerAssetFillAmount', makerAssetFillAmount);
+        assert.isValidBaseUnitAmount('slippageBufferAmount', slippageBufferAmount);
+        assert.assert(
+            signedOrders.length === remainingFillableMakerAssetAmounts.length,
+            'Expected signedOrders.length to equal remainingFillableMakerAssetAmounts.length',
+        );
+        // calculate total amount of makerAsset needed to be filled
+        const totalFillAmount = makerAssetFillAmount.plus(slippageBufferAmount);
+        // iterate through the signedOrders input from left to right until we have enough makerAsset to fill totalFillAmount
+        const result = _.reduce(
+            signedOrders,
+            ({ resultOrders, remainingFillAmount }, order, index) => {
+                if (remainingFillAmount.lessThanOrEqualTo(constants.ZERO_AMOUNT)) {
+                    return { resultOrders, remainingFillAmount: constants.ZERO_AMOUNT };
+                } else {
+                    const makerAssetAmountAvailable = remainingFillableMakerAssetAmounts[index];
+                    // if there is no makerAssetAmountAvailable do not append order to resultOrders
+                    // if we have exceeded the total amount we want to fill set remainingFillAmount to 0
+                    return {
+                        resultOrders: makerAssetAmountAvailable.gt(constants.ZERO_AMOUNT)
+                            ? _.concat(resultOrders, order)
+                            : resultOrders,
+                        remainingFillAmount: BigNumber.max(
+                            constants.ZERO_AMOUNT,
+                            remainingFillAmount.minus(makerAssetAmountAvailable),
+                        ),
+                    };
+                }
+            },
+            { resultOrders: [] as SignedOrder[], remainingFillAmount: totalFillAmount },
+        );
+        return result;
+    },
+    /**
+     * Takes an array of orders and an array of feeOrders. Returns a subset of the feeOrders that has enough ZRX (taking into account
+     * on-chain balances, allowances, and partial fills) in order to fill the takerFees required by signedOrders plus a
+     * slippageBufferAmount. Iterates from first feeOrder to last. Sort the feeOrders by ascending rate in order to get the subset of
+     * feeOrders that will cost the least ETH.
+     * @param   signedOrders                        An array of objects that conform to the SignedOrder interface. All orders should specify ZRX as
+     *                                              the makerAsset and WETH as the takerAsset.
+     * @param   remainingFillableMakerAssetAmounts  An array of BigNumbers corresponding to the signedOrders parameter.
+     *                                              You can use OrderStateUtils @0xproject/order-utils to perform blockchain lookups
+     *                                              for these values.
+     * @param   signedFeeOrders                     An array of objects that conform to the SignedOrder interface. All orders should specify ZRX as
+     *                                              the makerAsset and WETH as the takerAsset.
+     * @param   remainingFillableFeeAmounts         An array of BigNumbers corresponding to the signedFeeOrders parameter.
+     *                                              You can use OrderStateUtils @0xproject/order-utils to perform blockchain lookups
+     *                                              for these values.
+     * @param   slippageBufferAmount                An additional amount of fee to be covered by the result in case of trade collisions or partial fills.
+     * @return  Resulting orders and remaining fee amount that could not be covered by the input.
+     */
+    findFeeOrdersThatCoverFeesForTargetOrders(
+        signedOrders: SignedOrder[],
+        remainingFillableMakerAssetAmounts: BigNumber[],
+        signedFeeOrders: SignedOrder[],
+        remainingFillableFeeAmounts: BigNumber[],
+        slippageBufferAmount: BigNumber = constants.ZERO_AMOUNT,
+    ): { resultOrders: SignedOrder[]; remainingFeeAmount: BigNumber } {
+        assert.doesConformToSchema('signedOrders', signedOrders, schemas.signedOrdersSchema);
+        _.forEach(remainingFillableMakerAssetAmounts, (amount, index) =>
+            assert.isValidBaseUnitAmount(`remainingFillableMakerAssetAmount[${index}]`, amount),
+        );
+        assert.doesConformToSchema('signedFeeOrders', signedFeeOrders, schemas.signedOrdersSchema);
+        _.forEach(remainingFillableFeeAmounts, (amount, index) =>
+            assert.isValidBaseUnitAmount(`remainingFillableFeeAmounts[${index}]`, amount),
+        );
+        assert.isValidBaseUnitAmount('slippageBufferAmount', slippageBufferAmount);
+        assert.assert(
+            signedOrders.length === remainingFillableMakerAssetAmounts.length,
+            'Expected signedOrders.length to equal remainingFillableMakerAssetAmounts.length',
+        );
+        assert.assert(
+            signedOrders.length === remainingFillableMakerAssetAmounts.length,
+            'Expected signedFeeOrders.length to equal remainingFillableFeeAmounts.length',
+        );
+        // calculate total amount of ZRX needed to fill signedOrders
+        const totalFeeAmount = _.reduce(
+            signedOrders,
+            (accFees, order, index) => {
+                const makerAssetAmountAvailable = remainingFillableMakerAssetAmounts[index];
+                const feeToFillMakerAssetAmountAvailable = makerAssetAmountAvailable
+                    .mul(order.takerFee)
+                    .div(order.makerAssetAmount);
+                return accFees.plus(feeToFillMakerAssetAmountAvailable);
+            },
+            constants.ZERO_AMOUNT,
+        );
+        const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
+            signedFeeOrders,
+            remainingFillableFeeAmounts,
+            totalFeeAmount,
+            slippageBufferAmount,
+        );
+        return {
+            resultOrders,
+            remainingFeeAmount: remainingFillAmount,
+        };
+        // TODO: add more orders here to cover rounding
+        // https://github.com/0xProject/0x-protocol-specification/blob/master/v2/forwarding-contract-specification.md#over-buying-zrx
+    },
+};
diff --git a/packages/order-utils/src/order_factory.ts b/packages/order-utils/src/order_factory.ts
index 14122f353..46a69ae4d 100644
--- a/packages/order-utils/src/order_factory.ts
+++ b/packages/order-utils/src/order_factory.ts
@@ -1,75 +1,90 @@
-import { ECSignature, SignedOrder } from '@0xproject/types';
+import { Order, SignedOrder, SignerType } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import { Provider } from 'ethereum-types';
-import * as ethUtil from 'ethereumjs-util';
 import * as _ from 'lodash';
 
+import { constants } from './constants';
 import { orderHashUtils } from './order_hash';
 import { generatePseudoRandomSalt } from './salt';
 import { signatureUtils } from './signature_utils';
-import { MessagePrefixType } from './types';
+import { CreateOrderOpts } from './types';
 
 export const orderFactory = {
-    async createSignedOrderAsync(
-        provider: Provider,
+    createOrder(
         makerAddress: string,
-        takerAddress: string,
-        senderAddress: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
         makerAssetAmount: BigNumber,
         makerAssetData: string,
         takerAssetAmount: BigNumber,
         takerAssetData: string,
         exchangeAddress: string,
-        feeRecipientAddress: string,
-        expirationTimeSecondsIfExists?: BigNumber,
-    ): Promise<SignedOrder> {
-        const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
-        const expirationTimeSeconds = _.isUndefined(expirationTimeSecondsIfExists)
-            ? defaultExpirationUnixTimestampSec
-            : expirationTimeSecondsIfExists;
+        createOrderOpts: CreateOrderOpts = generateDefaultCreateOrderOpts(),
+    ): Order {
+        const defaultCreateOrderOpts = generateDefaultCreateOrderOpts();
         const order = {
             makerAddress,
-            takerAddress,
-            senderAddress,
-            makerFee,
-            takerFee,
             makerAssetAmount,
             takerAssetAmount,
             makerAssetData,
             takerAssetData,
-            salt: generatePseudoRandomSalt(),
             exchangeAddress,
-            feeRecipientAddress,
-            expirationTimeSeconds,
+            takerAddress: createOrderOpts.takerAddress || defaultCreateOrderOpts.takerAddress,
+            senderAddress: createOrderOpts.senderAddress || defaultCreateOrderOpts.senderAddress,
+            makerFee: createOrderOpts.makerFee || defaultCreateOrderOpts.makerFee,
+            takerFee: createOrderOpts.takerFee || defaultCreateOrderOpts.takerFee,
+            feeRecipientAddress: createOrderOpts.feeRecipientAddress || defaultCreateOrderOpts.feeRecipientAddress,
+            salt: createOrderOpts.salt || defaultCreateOrderOpts.salt,
+            expirationTimeSeconds:
+                createOrderOpts.expirationTimeSeconds || defaultCreateOrderOpts.expirationTimeSeconds,
         };
+        return order;
+    },
+    async createSignedOrderAsync(
+        provider: Provider,
+        makerAddress: string,
+        makerAssetAmount: BigNumber,
+        makerAssetData: string,
+        takerAssetAmount: BigNumber,
+        takerAssetData: string,
+        exchangeAddress: string,
+        createOrderOpts?: CreateOrderOpts,
+    ): Promise<SignedOrder> {
+        const order = orderFactory.createOrder(
+            makerAddress,
+            makerAssetAmount,
+            makerAssetData,
+            takerAssetAmount,
+            takerAssetData,
+            exchangeAddress,
+            createOrderOpts,
+        );
         const orderHash = orderHashUtils.getOrderHashHex(order);
-        const messagePrefixOpts = {
-            prefixType: MessagePrefixType.EthSign,
-            shouldAddPrefixBeforeCallingEthSign: false,
-        };
-        const ecSignature = await signatureUtils.ecSignOrderHashAsync(
+        const signature = await signatureUtils.ecSignOrderHashAsync(
             provider,
             orderHash,
             makerAddress,
-            messagePrefixOpts,
+            SignerType.Default,
         );
-        const signature = getVRSHexString(ecSignature);
         const signedOrder: SignedOrder = _.assign(order, { signature });
         return signedOrder;
     },
 };
 
-function getVRSHexString(ecSignature: ECSignature): string {
-    const ETH_SIGN_SIGNATURE_TYPE = '03';
-    const vrs = `${intToHex(ecSignature.v)}${ethUtil.stripHexPrefix(ecSignature.r)}${ethUtil.stripHexPrefix(
-        ecSignature.s,
-    )}${ETH_SIGN_SIGNATURE_TYPE}`;
-    return vrs;
-}
-
-function intToHex(i: number): string {
-    const hex = ethUtil.bufferToHex(ethUtil.toBuffer(i));
-    return hex;
+function generateDefaultCreateOrderOpts(): {
+    takerAddress: string;
+    senderAddress: string;
+    makerFee: BigNumber;
+    takerFee: BigNumber;
+    feeRecipientAddress: string;
+    salt: BigNumber;
+    expirationTimeSeconds: BigNumber;
+} {
+    return {
+        takerAddress: constants.NULL_ADDRESS,
+        senderAddress: constants.NULL_ADDRESS,
+        makerFee: constants.ZERO_AMOUNT,
+        takerFee: constants.ZERO_AMOUNT,
+        feeRecipientAddress: constants.NULL_ADDRESS,
+        salt: generatePseudoRandomSalt(),
+        expirationTimeSeconds: constants.INFINITE_TIMESTAMP_SEC,
+    };
 }
diff --git a/packages/order-utils/src/signature_utils.ts b/packages/order-utils/src/signature_utils.ts
index 2dc465256..d466bb00d 100644
--- a/packages/order-utils/src/signature_utils.ts
+++ b/packages/order-utils/src/signature_utils.ts
@@ -1,5 +1,5 @@
 import { schemas } from '@0xproject/json-schemas';
-import { ECSignature, SignatureType, ValidatorSignature } from '@0xproject/types';
+import { ECSignature, SignatureType, SignerType, ValidatorSignature } from '@0xproject/types';
 import { Web3Wrapper } from '@0xproject/web3-wrapper';
 import { Provider } from 'ethereum-types';
 import * as ethUtil from 'ethereumjs-util';
@@ -10,13 +10,12 @@ import { assert } from './assert';
 import { ExchangeContract } from './generated_contract_wrappers/exchange';
 import { IValidatorContract } from './generated_contract_wrappers/i_validator';
 import { IWalletContract } from './generated_contract_wrappers/i_wallet';
-import { MessagePrefixOpts, MessagePrefixType, OrderError } from './types';
+import { OrderError } from './types';
 import { utils } from './utils';
 
 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]
@@ -50,7 +49,7 @@ export const signatureUtils = {
 
             case SignatureType.EthSign: {
                 const ecSignature = signatureUtils.parseECSignature(signature);
-                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, MessagePrefixType.EthSign);
+                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, SignerType.EthSign);
                 return signatureUtils.isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
             }
 
@@ -84,7 +83,7 @@ export const signatureUtils = {
             }
 
             case SignatureType.Trezor: {
-                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, MessagePrefixType.Trezor);
+                const prefixedMessageHex = signatureUtils.addSignedMessagePrefix(data, SignerType.Trezor);
                 const ecSignature = signatureUtils.parseECSignature(signature);
                 return signatureUtils.isValidECSignature(prefixedMessageHex, ecSignature, signerAddress);
             }
@@ -202,23 +201,21 @@ export const signatureUtils = {
         }
     },
     /**
-     * Signs an orderHash and returns it's elliptic curve signature.
+     * Signs an orderHash and returns it's elliptic curve signature and signature type.
      * 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
+     * @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.
+     * @param   signerType Different signers add/require different prefixes to be prepended to the message being signed.
+     *          Since we cannot know ahead of time which signer you are using, you must supply a SignerType.
+     * @return  A hex encoded string containing the Elliptic curve signature generated by signing the orderHash and the Signature Type.
      */
     async ecSignOrderHashAsync(
         provider: Provider,
         orderHash: string,
         signerAddress: string,
-        messagePrefixOpts: MessagePrefixOpts,
-    ): Promise<ECSignature> {
+        signerType: SignerType,
+    ): Promise<string> {
         assert.isWeb3Provider('provider', provider);
         assert.isHexString('orderHash', orderHash);
         assert.isETHAddressHex('signerAddress', signerAddress);
@@ -227,8 +224,10 @@ export const signatureUtils = {
         const normalizedSignerAddress = signerAddress.toLowerCase();
 
         let msgHashHex = orderHash;
-        const prefixedMsgHashHex = signatureUtils.addSignedMessagePrefix(orderHash, messagePrefixOpts.prefixType);
-        if (messagePrefixOpts.shouldAddPrefixBeforeCallingEthSign) {
+        const prefixedMsgHashHex = signatureUtils.addSignedMessagePrefix(orderHash, signerType);
+        // Metamask incorrectly implements eth_sign and does not prefix the message as per the spec
+        // Source: https://github.com/MetaMask/metamask-extension/commit/a9d36860bec424dcee8db043d3e7da6a5ff5672e
+        if (signerType === SignerType.Metamask) {
             msgHashHex = prefixedMsgHashHex;
         }
         const signature = await web3Wrapper.signMessageAsync(normalizedSignerAddress, msgHashHex);
@@ -237,8 +236,24 @@ export const signatureUtils = {
         // 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.
+        // r + s + v is the most prevalent format from eth_sign, so we attempt this first.
         // tslint:disable-next-line:custom-no-magic-numbers
         const validVParamValues = [27, 28];
+        const ecSignatureRSV = parseSignatureHexAsRSV(signature);
+        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
+            const isValidRSVSignature = signatureUtils.isValidECSignature(
+                prefixedMsgHashHex,
+                ecSignatureRSV,
+                normalizedSignerAddress,
+            );
+            if (isValidRSVSignature) {
+                const convertedSignatureHex = signatureUtils.convertECSignatureToSignatureHex(
+                    ecSignatureRSV,
+                    signerType,
+                );
+                return convertedSignatureHex;
+            }
+        }
         const ecSignatureVRS = parseSignatureHexAsVRS(signature);
         if (_.includes(validVParamValues, ecSignatureVRS.v)) {
             const isValidVRSSignature = signatureUtils.isValidECSignature(
@@ -247,54 +262,85 @@ export const signatureUtils = {
                 normalizedSignerAddress,
             );
             if (isValidVRSSignature) {
-                return ecSignatureVRS;
+                const convertedSignatureHex = signatureUtils.convertECSignatureToSignatureHex(
+                    ecSignatureVRS,
+                    signerType,
+                );
+                return convertedSignatureHex;
             }
         }
 
-        const ecSignatureRSV = parseSignatureHexAsRSV(signature);
-        if (_.includes(validVParamValues, ecSignatureRSV.v)) {
-            const isValidRSVSignature = signatureUtils.isValidECSignature(
-                prefixedMsgHashHex,
-                ecSignatureRSV,
-                normalizedSignerAddress,
-            );
-            if (isValidRSVSignature) {
-                return ecSignatureRSV;
+        throw new Error(OrderError.InvalidSignature);
+    },
+    /**
+     * Combines ECSignature with V,R,S and the relevant signature type for use in 0x protocol
+     * @param ecSignature The ECSignature of the signed data
+     * @param signerType The SignerType of the signed data
+     * @return Hex encoded string of signature (v,r,s) with Signature Type
+     */
+    convertECSignatureToSignatureHex(ecSignature: ECSignature, signerType: SignerType): string {
+        const signatureBuffer = Buffer.concat([
+            ethUtil.toBuffer(ecSignature.v),
+            ethUtil.toBuffer(ecSignature.r),
+            ethUtil.toBuffer(ecSignature.s),
+        ]);
+        const signatureHex = `0x${signatureBuffer.toString('hex')}`;
+        let signatureType;
+        switch (signerType) {
+            case SignerType.Metamask:
+            case SignerType.Ledger:
+            case SignerType.Default: {
+                signatureType = SignatureType.EthSign;
+                break;
             }
+            case SignerType.Trezor: {
+                signatureType = SignatureType.Trezor;
+                break;
+            }
+            default:
+                throw new Error(`Unrecognized SignerType: ${signerType}`);
         }
-
-        throw new Error(OrderError.InvalidSignature);
+        const signatureWithType = signatureUtils.convertToSignatureWithType(signatureHex, signatureType);
+        return signatureWithType;
+    },
+    /**
+     * Combines the signature proof and the Signature Type.
+     * @param signature The hex encoded signature proof
+     * @param signatureType The signature type, i.e EthSign, Trezor, Wallet etc.
+     * @return Hex encoded string of signature proof with Signature Type
+     */
+    convertToSignatureWithType(signature: string, signatureType: SignatureType): string {
+        const signatureBuffer = Buffer.concat([ethUtil.toBuffer(signature), ethUtil.toBuffer(signatureType)]);
+        const signatureHex = `0x${signatureBuffer.toString('hex')}`;
+        return signatureHex;
     },
     /**
      * 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
+     * @param signerType The type of message prefix to add for a given SignerType. Different signers expect
      *                          specific message prefixes.
      * @return Prefixed message
      */
-    addSignedMessagePrefix(message: string, messagePrefixType: MessagePrefixType): string {
+    addSignedMessagePrefix(message: string, signerType: SignerType = SignerType.Default): string {
         assert.isString('message', message);
-        assert.doesBelongToStringEnum('messagePrefixType', messagePrefixType, MessagePrefixType);
-        switch (messagePrefixType) {
-            case MessagePrefixType.None:
-                return message;
-
-            case MessagePrefixType.EthSign: {
+        assert.doesBelongToStringEnum('signerType', signerType, SignerType);
+        switch (signerType) {
+            case SignerType.Metamask:
+            case SignerType.Ledger:
+            case SignerType.Default: {
                 const msgBuff = ethUtil.toBuffer(message);
                 const prefixedMsgBuff = ethUtil.hashPersonalMessage(msgBuff);
                 const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
                 return prefixedMsgHex;
             }
-
-            case MessagePrefixType.Trezor: {
+            case SignerType.Trezor: {
                 const msgBuff = ethUtil.toBuffer(message);
                 const prefixedMsgBuff = hashTrezorPersonalMessage(msgBuff);
                 const prefixedMsgHex = ethUtil.bufferToHex(prefixedMsgBuff);
                 return prefixedMsgHex;
             }
-
             default:
-                throw new Error(`Unrecognized MessagePrefixType: ${messagePrefixType}`);
+                throw new Error(`Unrecognized SignerType: ${signerType}`);
         }
     },
     /**
diff --git a/packages/order-utils/src/types.ts b/packages/order-utils/src/types.ts
index b08e74e71..1fbd8cf7b 100644
--- a/packages/order-utils/src/types.ts
+++ b/packages/order-utils/src/types.ts
@@ -1,29 +1,9 @@
+import { BigNumber } from '@0xproject/utils';
+
 export enum OrderError {
     InvalidSignature = 'INVALID_SIGNATURE',
 }
 
-/**
- * The requisite message prefix (is any) to add to an `eth_sign` request.
- */
-export enum MessagePrefixType {
-    None = 'NONE',
-    EthSign = 'ETH_SIGN',
-    Trezor = 'TREZOR',
-}
-
-/**
- * Options related to message prefixing of messages sent to `eth_sign`
- * Some signers prepend a message prefix (e.g Parity Signer, Ledger, TestRPC), while
- * others require it already be prepended (e.g Metamask). In addition, different signers
- * expect slightly different prefixes (See: https://github.com/ethereum/go-ethereum/issues/14794).
- * Depending on the signer that will receive your signing request, you must specify the
- * desired prefix and whether it should be added before making the `eth_sign` request.
- */
-export interface MessagePrefixOpts {
-    prefixType: MessagePrefixType;
-    shouldAddPrefixBeforeCallingEthSign: boolean;
-}
-
 export enum TradeSide {
     Maker = 'maker',
     Taker = 'taker',
@@ -51,3 +31,13 @@ export enum EIP712Types {
     String = 'string',
     Uint256 = 'uint256',
 }
+
+export interface CreateOrderOpts {
+    takerAddress?: string;
+    senderAddress?: string;
+    makerFee?: BigNumber;
+    takerFee?: BigNumber;
+    feeRecipientAddress?: string;
+    salt?: BigNumber;
+    expirationTimeSeconds?: BigNumber;
+}