Update Order utils to use eip712

1 files changed, 30 insertions, 45 deletions

diff --git a/packages/order-utils/src/order_hash.ts b/packages/order-utils/src/order_hash.ts
index 2ef746ef8..b2414febc 100644
--- a/packages/order-utils/src/order_hash.ts
+++ b/packages/order-utils/src/order_hash.ts
@@ -9,9 +9,29 @@ import * as _ from 'lodash';
 
 import { assert } from './assert';
 import { crypto } from './crypto';
+import { EIP712Utils } from './eip712_utils';
+import { EIP712Schema } from './types';
 
 const INVALID_TAKER_FORMAT = 'instance.takerAddress is not of a type(s) string';
 
+const EIP712_ORDER_SCHEMA: EIP712Schema = {
+    name: 'Order',
+    parameters: [
+        { name: 'makerAddress', type: 'address' },
+        { name: 'takerAddress', type: 'address' },
+        { name: 'feeRecipientAddress', type: 'address' },
+        { name: 'senderAddress', type: 'address' },
+        { name: 'makerAssetAmount', type: 'uint256' },
+        { name: 'takerAssetAmount', type: 'uint256' },
+        { name: 'makerFee', type: 'uint256' },
+        { name: 'takerFee', type: 'uint256' },
+        { name: 'expirationTimeSeconds', type: 'uint256' },
+        { name: 'salt', type: 'uint256' },
+        { name: 'makerAssetData', type: 'bytes' },
+        { name: 'takerAssetData', type: 'bytes' },
+    ],
+};
+
 export const orderHashUtils = {
     /**
      * Checks if the supplied hex encoded order hash is valid.
@@ -45,7 +65,7 @@ export const orderHashUtils = {
             throw error;
         }
 
-        const orderHashBuff = this.getOrderHashBuff(order);
+        const orderHashBuff = orderHashUtils.getOrderHashBuffer(order);
         const orderHashHex = `0x${orderHashBuff.toString('hex')}`;
         return orderHashHex;
     },
@@ -54,15 +74,16 @@ export const orderHashUtils = {
      * @param   order   An object that conforms to the Order or SignedOrder interface definitions.
      * @return  The resulting orderHash from hashing the supplied order as a Buffer
      */
-    getOrderHashBuff(order: SignedOrder | Order): Buffer {
+    getOrderHashBuffer(order: SignedOrder | Order): 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,
+            orderHashUtils._getOrderSchemaBuffer(),
+            EIP712Utils.pad32Address(order.makerAddress),
+            EIP712Utils.pad32Address(order.takerAddress),
+            EIP712Utils.pad32Address(order.feeRecipientAddress),
+            EIP712Utils.pad32Address(order.senderAddress),
             order.makerAssetAmount,
             order.takerAssetAmount,
             order.makerFee,
@@ -72,46 +93,10 @@ export const orderHashUtils = {
             makerAssetDataHash,
             takerAssetDataHash,
         ]);
-        const orderParamsHashHex = `0x${orderParamsHashBuff.toString('hex')}`;
-        const orderSchemaHashHex = this._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),
-        ]);
+        const orderHashBuff = EIP712Utils.createEIP712Message(orderParamsHashBuff, order.exchangeAddress);
         return orderHashBuff;
     },
-    _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;
-    },
-    _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;
+    _getOrderSchemaBuffer(): Buffer {
+        return EIP712Utils.compileSchema(EIP712_ORDER_SCHEMA);
     },
 };