Initial refactor of order-utils. Move many utils from contracts into this package.

1 files changed, 5 insertions, 67 deletions

diff --git a/packages/contracts/src/utils/order_utils.ts b/packages/contracts/src/utils/order_utils.ts
index 6d1aaa06b..dd7a04cb6 100644
--- a/packages/contracts/src/utils/order_utils.ts
+++ b/packages/contracts/src/utils/order_utils.ts
@@ -1,8 +1,7 @@
-import { Order, SignedOrder, UnsignedOrder } from '@0xproject/types';
+import { Order, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import ethUtil = require('ethereumjs-util');
 
-import { crypto } from './crypto';
 import { CancelOrder, MatchOrder } from './types';
 
 export const orderUtils = {
@@ -21,6 +20,9 @@ export const orderUtils = {
         };
         return cancel;
     },
+    // TODO: This seems redundant... it currently returns a deep copy w/o signature.
+    // Question: Should we still have a separate OrderStruct type that simply doesn't
+    // include the exchangeAddress? Seems like we need to for batch ops...
     getOrderStruct(signedOrder: SignedOrder): Order {
         const orderStruct = {
             senderAddress: signedOrder.senderAddress,
@@ -35,74 +37,10 @@ export const orderUtils = {
             salt: signedOrder.salt,
             makerAssetData: signedOrder.makerAssetData,
             takerAssetData: signedOrder.takerAssetData,
+            exchangeAddress: signedOrder.exchangeAddress,
         };
         return orderStruct;
     },
-    getDomainSeparatorSchemaHex(): string {
-        const domainSeparatorSchemaHashBuff = crypto.solSHA3(['DomainSeparator(address contract)']);
-        const schemaHashHex = `0x${domainSeparatorSchemaHashBuff.toString('hex')}`;
-        return schemaHashHex;
-    },
-    getDomainSeparatorHashHex(exchangeAddress: string): string {
-        const domainSeparatorHashBuff = crypto.solSHA3([exchangeAddress]);
-        const domainSeparatorHashHex = `0x${domainSeparatorHashBuff.toString('hex')}`;
-        return domainSeparatorHashHex;
-    },
-    getOrderSchemaHex(): string {
-        const orderSchemaHashBuff = crypto.solSHA3([
-            'Order(',
-            'address makerAddress,',
-            'address takerAddress,',
-            'address feeRecipientAddress,',
-            'address senderAddress,',
-            'uint256 makerAssetAmount,',
-            'uint256 takerAssetAmount,',
-            'uint256 makerFee,',
-            'uint256 takerFee,',
-            'uint256 expirationTimeSeconds,',
-            'uint256 salt,',
-            'bytes makerAssetData,',
-            'bytes takerAssetData,',
-            ')',
-        ]);
-        const schemaHashHex = `0x${orderSchemaHashBuff.toString('hex')}`;
-        return schemaHashHex;
-    },
-    getOrderHashBuff(order: SignedOrder | UnsignedOrder): Buffer {
-        const makerAssetDataHash = crypto.solSHA3([ethUtil.toBuffer(order.makerAssetData)]);
-        const takerAssetDataHash = crypto.solSHA3([ethUtil.toBuffer(order.takerAssetData)]);
-
-        const orderParamsHashBuff = crypto.solSHA3([
-            order.makerAddress,
-            order.takerAddress,
-            order.feeRecipientAddress,
-            order.senderAddress,
-            order.makerAssetAmount,
-            order.takerAssetAmount,
-            order.makerFee,
-            order.takerFee,
-            order.expirationTimeSeconds,
-            order.salt,
-            makerAssetDataHash,
-            takerAssetDataHash,
-        ]);
-        const orderParamsHashHex = `0x${orderParamsHashBuff.toString('hex')}`;
-        const orderSchemaHashHex = orderUtils.getOrderSchemaHex();
-        const domainSeparatorHashHex = this.getDomainSeparatorHashHex(order.exchangeAddress);
-        const domainSeparatorSchemaHex = this.getDomainSeparatorSchemaHex();
-        const orderHashBuff = crypto.solSHA3([
-            new BigNumber(domainSeparatorSchemaHex),
-            new BigNumber(domainSeparatorHashHex),
-            new BigNumber(orderSchemaHashHex),
-            new BigNumber(orderParamsHashHex),
-        ]);
-        return orderHashBuff;
-    },
-    getOrderHashHex(order: SignedOrder | UnsignedOrder): string {
-        const orderHashBuff = orderUtils.getOrderHashBuff(order);
-        const orderHashHex = `0x${orderHashBuff.toString('hex')}`;
-        return orderHashHex;
-    },
     createMatchOrders(signedOrderLeft: SignedOrder, signedOrderRight: SignedOrder): MatchOrder {
         const fill = {
             left: orderUtils.getOrderStruct(signedOrderLeft),