Return SignedOrder from signing utils.

Create a helper back in EIP712Utils for code cleanup.
Moved constants in order-utils into the constants object

3 files changed, 106 insertions, 3 deletions

diff --git a/packages/order-utils/test/eip712_utils_test.ts b/packages/order-utils/test/eip712_utils_test.ts
new file mode 100644
index 000000000..dc76595db
--- /dev/null
+++ b/packages/order-utils/test/eip712_utils_test.ts
@@ -0,0 +1,44 @@
+import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
+import 'mocha';
+
+import { constants } from '../src/constants';
+import { eip712Utils } from '../src/eip712_utils';
+
+import { chaiSetup } from './utils/chai_setup';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('EIP712 Utils', () => {
+    describe('createTypedData', () => {
+        it('adds in the EIP712DomainSeparator', () => {
+            const primaryType = 'Test';
+            const typedData = eip712Utils.createTypedData(
+                primaryType,
+                { Test: [{ name: 'testValue', type: 'uint256' }] },
+                { testValue: '1' },
+                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(typedData.primaryType).to.eq(primaryType);
+        });
+    });
+    describe('createTypedData', () => {
+        it('adds in the EIP712DomainSeparator', () => {
+            const typedData = eip712Utils.createZeroExTransactionTypedData(
+                {
+                    salt: new BigNumber('0'),
+                    data: constants.NULL_BYTES,
+                    signerAddress: constants.NULL_BYTES,
+                },
+                constants.NULL_ADDRESS,
+            );
+            expect(typedData.primaryType).to.eq(constants.EIP712_ZEROEX_TRANSACTION_SCHEMA.name);
+            expect(typedData.types.EIP712Domain).to.not.be.undefined();
+        });
+    });
+});
diff --git a/packages/order-utils/test/order_hash_test.ts b/packages/order-utils/test/order_hash_test.ts
index 3fdbbad21..fe44218d6 100644
--- a/packages/order-utils/test/order_hash_test.ts
+++ b/packages/order-utils/test/order_hash_test.ts
@@ -35,6 +35,20 @@ describe('Order hashing', () => {
             const orderHash = orderHashUtils.getOrderHashHex(order);
             expect(orderHash).to.be.equal(expectedOrderHash);
         });
+        it('calculates the order 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 orderHash = orderHashUtils.getOrderHashHex({
+                ...order,
+                makerAssetAmount: '0',
+                takerAssetAmount: '0',
+                makerFee: '0',
+                takerFee: '0',
+            } as any);
+            expect(orderHash).to.be.equal(expectedOrderHash);
+        });
         it('throws a readable error message if taker format is invalid', async () => {
             const orderWithInvalidtakerFormat = {
                 ...order,
diff --git a/packages/order-utils/test/signature_utils_test.ts b/packages/order-utils/test/signature_utils_test.ts
index 03354cd65..7f6987f6a 100644
--- a/packages/order-utils/test/signature_utils_test.ts
+++ b/packages/order-utils/test/signature_utils_test.ts
@@ -152,14 +152,14 @@ describe('Signature utils', () => {
                 ethUtil.toBuffer(SignatureType.EIP712),
             ]);
             const signatureHex = `0x${signatureBuffer.toString('hex')}`;
-            const eip712Signature = await signatureUtils.ecSignOrderAsync(provider, order, makerAddress);
+            const signedOrder = await signatureUtils.ecSignOrderAsync(provider, order, makerAddress);
             const isValidSignature = await signatureUtils.isValidSignatureAsync(
                 provider,
                 orderHashHex,
-                eip712Signature,
+                signedOrder.signature,
                 makerAddress,
             );
-            expect(signatureHex).to.eq(eip712Signature);
+            expect(signatureHex).to.eq(signedOrder.signature);
             expect(isValidSignature).to.eq(true);
         });
     });
@@ -238,6 +238,51 @@ describe('Signature utils', () => {
             expect(isValidSignature).to.be.true();
         });
     });
+    describe('#ecSignTypedDataOrderAsync', () => {
+        let makerAddress: string;
+        const fakeExchangeContractAddress = '0x1dc4c1cefef38a777b15aa20260a54e584b16c48';
+        let order: Order;
+        before(async () => {
+            const availableAddreses = await web3Wrapper.getAvailableAddressesAsync();
+            makerAddress = availableAddreses[0];
+            order = {
+                makerAddress,
+                takerAddress: constants.NULL_ADDRESS,
+                senderAddress: constants.NULL_ADDRESS,
+                feeRecipientAddress: constants.NULL_ADDRESS,
+                makerAssetData: constants.NULL_ADDRESS,
+                takerAssetData: constants.NULL_ADDRESS,
+                exchangeAddress: fakeExchangeContractAddress,
+                salt: new BigNumber(0),
+                makerFee: new BigNumber(0),
+                takerFee: new BigNumber(0),
+                makerAssetAmount: new BigNumber(0),
+                takerAssetAmount: new BigNumber(0),
+                expirationTimeSeconds: new BigNumber(0),
+            };
+        });
+        it('should return the correct Signature for signatureHex concatenated as R + S + V', async () => {
+            const expectedSignature =
+                '0x1cd472c439833774b55d248c31b6585f21aea1b9363ebb4ec58549e46b62eb5a6f696f5781f62de008ee7f77650ef940d99c97ec1dee67b3f5cea1bbfdfeb2eba602';
+            const fakeProvider = {
+                async sendAsync(payload: JSONRPCRequestPayload, callback: JSONRPCErrorCallback): Promise<void> {
+                    if (payload.method === 'eth_signTypedData') {
+                        const [address, typedData] = payload.params;
+                        const signature = await web3Wrapper.signTypedDataAsync(address, typedData);
+                        callback(null, {
+                            id: 42,
+                            jsonrpc: '2.0',
+                            result: signature,
+                        });
+                    } else {
+                        callback(null, { id: 42, jsonrpc: '2.0', result: [makerAddress] });
+                    }
+                },
+            };
+            const signedOrder = await signatureUtils.ecSignTypedDataOrderAsync(fakeProvider, order, makerAddress);
+            expect(signedOrder.signature).to.equal(expectedSignature);
+        });
+    });
     describe('#convertECSignatureToSignatureHex', () => {
         const ecSignature: ECSignature = {
             v: 27,