3 files changed, 100 insertions, 16 deletions
diff --git a/packages/order-utils/test/eip712_utils_test.ts b/packages/order-utils/test/eip712_utils_test.ts
index a54e49958..4208e9beb 100644
--- a/packages/order-utils/test/eip712_utils_test.ts
+++ b/packages/order-utils/test/eip712_utils_test.ts
@@ -3,7 +3,12 @@ import * as chai from 'chai';
 import 'mocha';
 
 import { constants } from '../src/constants';
-import { eip712Utils } from '../src/eip712_utils';
+import {
+    eip712Utils,
+    EXCHANGE_DOMAIN_NAME,
+    EXCHANGE_DOMAIN_VERSION,
+    EXCHANGE_ZEROEX_TRANSACTION_SCHEMA,
+} from '../src/eip712_utils';
 
 import { chaiSetup } from './utils/chai_setup';
 
@@ -12,33 +17,55 @@ const expect = chai.expect;
 
 describe('EIP712 Utils', () => {
     describe('createTypedData', () => {
-        it('adds in the EIP712DomainSeparator', () => {
+        it('adds in the EIP712DomainSeparator with default values', () => {
             const primaryType = 'Test';
             const typedData = eip712Utils.createTypedData(
                 primaryType,
                 { Test: [{ name: 'testValue', type: 'uint256' }] },
                 { testValue: '1' },
-                constants.NULL_ADDRESS,
+                { verifyingContractAddress: constants.NULL_ADDRESS },
             );
             expect(typedData.domain).to.not.be.undefined();
             expect(typedData.types.EIP712Domain).to.not.be.undefined();
             const domainObject = typedData.domain;
-            expect(domainObject.name).to.eq(constants.EIP712_DOMAIN_NAME);
+            expect(domainObject.name).to.eq(EXCHANGE_DOMAIN_NAME);
+            expect(domainObject.version).to.eq(EXCHANGE_DOMAIN_VERSION);
+            expect(domainObject.verifyingContract).to.eq(constants.NULL_ADDRESS);
+            expect(typedData.primaryType).to.eq(primaryType);
+        });
+        it('adds in the EIP712DomainSeparator without default values', () => {
+            const primaryType = 'Test';
+            const domainName = 'testDomain';
+            const domainVersion = 'testVersion';
+            const typedData = eip712Utils.createTypedData(
+                primaryType,
+                { Test: [{ name: 'testValue', type: 'uint256' }] },
+                { testValue: '1' },
+                { name: domainName, version: domainVersion, verifyingContractAddress: constants.NULL_ADDRESS },
+            );
+            expect(typedData.domain).to.not.be.undefined();
+            expect(typedData.types.EIP712Domain).to.not.be.undefined();
+            const domainObject = typedData.domain;
+            expect(domainObject.name).to.eq(domainName);
+            expect(domainObject.version).to.eq(domainVersion);
+            expect(domainObject.verifyingContract).to.eq(constants.NULL_ADDRESS);
             expect(typedData.primaryType).to.eq(primaryType);
         });
     });
-    describe('createTypedData', () => {
+    describe('createZeroExTransactionTypedData', () => {
         it('adds in the EIP712DomainSeparator', () => {
-            const typedData = eip712Utils.createZeroExTransactionTypedData(
-                {
-                    salt: new BigNumber('0'),
-                    data: constants.NULL_BYTES,
-                    signerAddress: constants.NULL_ADDRESS,
-                },
-                constants.NULL_ADDRESS,
-            );
-            expect(typedData.primaryType).to.eq(constants.EIP712_ZEROEX_TRANSACTION_SCHEMA.name);
+            const typedData = eip712Utils.createZeroExTransactionTypedData({
+                salt: new BigNumber('0'),
+                data: constants.NULL_BYTES,
+                signerAddress: constants.NULL_ADDRESS,
+                verifyingContractAddress: constants.NULL_ADDRESS,
+            });
+            expect(typedData.primaryType).to.eq(EXCHANGE_ZEROEX_TRANSACTION_SCHEMA.name);
             expect(typedData.types.EIP712Domain).to.not.be.undefined();
+            const domainObject = typedData.domain;
+            expect(domainObject.name).to.eq(EXCHANGE_DOMAIN_NAME);
+            expect(domainObject.version).to.eq(EXCHANGE_DOMAIN_VERSION);
+            expect(domainObject.verifyingContract).to.eq(constants.NULL_ADDRESS);
         });
     });
 });
diff --git a/packages/order-utils/test/order_hash_test.ts b/packages/order-utils/test/order_hash_test.ts
index 30fb15a37..514fc2709 100644
--- a/packages/order-utils/test/order_hash_test.ts
+++ b/packages/order-utils/test/order_hash_test.ts
@@ -54,8 +54,9 @@ describe('Order hashing', () => {
                 ...order,
                 takerAddress: (null as any) as string,
             };
-            const expectedErrorMessage =
-                'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
+            const expectedErrorMessage = `Order taker must be of type string. If you want anyone to be able to fill an order - pass ${
+                constants.NULL_ADDRESS
+            }`;
             expect(() => orderHashUtils.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
         });
     });
diff --git a/packages/order-utils/test/transaction_hash_test.ts b/packages/order-utils/test/transaction_hash_test.ts
new file mode 100644
index 000000000..c7ca33a64
--- /dev/null
+++ b/packages/order-utils/test/transaction_hash_test.ts
@@ -0,0 +1,56 @@
+import { ZeroExTransaction } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as chai from 'chai';
+import 'mocha';
+
+import { transactionHashUtils } from '../src';
+
+import { constants } from '../src/constants';
+
+import { chaiSetup } from './utils/chai_setup';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('0x transaction hashing', () => {
+    describe('#getTransactionHashHex', () => {
+        const expectedTransactionHash = '0x82c9bb2dcac4f868ec7a15c20ff6175cfc384c20ae6a872aa0342a840f108c2b';
+        const fakeVerifyingContractAddress = '0x5e72914535f202659083db3a02c984188fa26e9f';
+        const transaction: ZeroExTransaction = {
+            verifyingContractAddress: fakeVerifyingContractAddress,
+            signerAddress: constants.NULL_ADDRESS,
+            salt: new BigNumber(0),
+            data: constants.NULL_BYTES,
+        };
+        it('calculates the transaction hash', async () => {
+            const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
+            expect(transactionHash).to.be.equal(expectedTransactionHash);
+        });
+        it('calculates the transaction hash if amounts are strings', async () => {
+            // It's common for developers using javascript to provide the amounts
+            // as strings. Since we eventually toString() the BigNumber
+            // before encoding we should result in the same orderHash in this scenario
+            // tslint:disable-next-line:no-unnecessary-type-assertion
+            const transactionHash = transactionHashUtils.getTransactionHashHex({
+                ...transaction,
+                salt: '0',
+            } as any);
+            expect(transactionHash).to.be.equal(expectedTransactionHash);
+        });
+    });
+    describe('#isValidTransactionHash', () => {
+        it('returns false if the value is not a hex string', () => {
+            const isValid = transactionHashUtils.isValidTransactionHash('not a hex');
+            expect(isValid).to.be.false();
+        });
+        it('returns false if the length is wrong', () => {
+            const isValid = transactionHashUtils.isValidTransactionHash('0xdeadbeef');
+            expect(isValid).to.be.false();
+        });
+        it('returns true if order hash is correct', () => {
+            const orderHashLength = 65;
+            const isValid = transactionHashUtils.isValidTransactionHash(`0x${Array(orderHashLength).join('0')}`);
+            expect(isValid).to.be.true();
+        });
+    });
+});