Remove domain from Order type

contracts/coordinator/test/coordinator.ts

@@ -111,10 +111,8 @@ describe('Coordinator tests', () => {
             takerAssetData: assetDataUtils.encodeERC20AssetData(erc20TokenB.address),
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(makerFeeToken.address),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(makerFeeToken.address),
-            domain: {
+            exchangeAddress: exchange.address,
-                verifyingContract: exchange.address,
             chainId,
-            },
         };
         const makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         const takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];

contracts/coordinator/test/mixins.ts

@@ -12,7 +12,7 @@ import {
 } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { transactionHashUtils } from '@0x/order-utils';
-import { EIP712DomainWithDefaultSchema, RevertReason, SignatureType, SignedOrder } from '@0x/types';
+import { RevertReason, SignatureType, SignedOrder } from '@0x/types';
 import { BigNumber, LibBytesRevertErrors, providerUtils } from '@0x/utils';
 import * as chai from 'chai';
 import * as ethUtil from 'ethereumjs-util';
@@ -34,7 +34,6 @@ describe('Mixins tests', () => {
     let approvalFactory2: ApprovalFactory;
     let defaultOrder: SignedOrder;
     const exchangeAddress = randomAddress();
-    let exchangeDomain: EIP712DomainWithDefaultSchema;
 
     before(async () => {
         await blockchainLifecycle.startAsync();
@@ -54,10 +53,6 @@ describe('Mixins tests', () => {
         );
         const accounts = await web3Wrapper.getAvailableAddressesAsync();
         [transactionSignerAddress, approvalSignerAddress1, approvalSignerAddress2] = accounts.slice(0, 3);
-        exchangeDomain = {
-            verifyingContract: constants.NULL_ADDRESS,
-            chainId,
-        };
         defaultOrder = {
             makerAddress: constants.NULL_ADDRESS,
             takerAddress: constants.NULL_ADDRESS,
@@ -74,7 +69,8 @@ describe('Mixins tests', () => {
             expirationTimeSeconds: constants.ZERO_AMOUNT,
             salt: constants.ZERO_AMOUNT,
             signature: constants.NULL_BYTES,
-            domain: exchangeDomain,
+            exchangeAddress: constants.NULL_ADDRESS,
+            chainId,
         };
         const transactionSignerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(transactionSignerAddress)];
         const approvalSignerPrivateKey1 = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(approvalSignerAddress1)];
@@ -152,7 +148,8 @@ describe('Mixins tests', () => {
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
-                    domain: exchangeDomain,
+                    exchangeAddress: constants.NULL_ADDRESS,
+                    chainId,
                 }));
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });
@@ -165,7 +162,8 @@ describe('Mixins tests', () => {
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
-                    domain: exchangeDomain,
+                    exchangeAddress: constants.NULL_ADDRESS,
+                    chainId,
                 }));
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });
@@ -178,7 +176,8 @@ describe('Mixins tests', () => {
                 const decodedSignedOrders = decodedOrders.map(order => ({
                     ...order,
                     signature: constants.NULL_BYTES,
-                    domain: exchangeDomain,
+                    exchangeAddress: constants.NULL_ADDRESS,
+                    chainId,
                 }));
                 expect(orders).to.deep.eq(decodedSignedOrders);
             });

contracts/dev-utils/test/order_validation_utils.ts

@@ -120,10 +120,8 @@ describe('OrderValidationUtils/OrderTransferSimulatorUtils', () => {
             takerAssetData: erc20AssetData2,
             makerFeeAssetData: feeAssetData,
             takerFeeAssetData: feeAssetData,
-            domain: {
+            exchangeAddress: exchange.address,
-                verifyingContract: exchange.address,
             chainId,
-            },
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

contracts/exchange-forwarder/test/forwarder.ts

@@ -120,10 +120,8 @@ blockchainTests(ContractName.Forwarder, env => {
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultMakerAssetAddress),
             makerFee: Web3Wrapper.toBaseUnitAmount(0, DECIMALS_DEFAULT),
             takerFee: Web3Wrapper.toBaseUnitAmount(0, DECIMALS_DEFAULT),
-            domain: {
+            exchangeAddress: exchangeInstance.address,
-                verifyingContract: exchangeInstance.address,
             chainId,
-            },
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

contracts/exchange-libs/src/reference_functions.ts

@@ -1,6 +1,6 @@
 import { ReferenceFunctions } from '@0x/contracts-utils';
 import { LibMathRevertErrors } from '@0x/order-utils';
-import { FillResults, OrderWithoutDomain } from '@0x/types';
+import { FillResults, Order } from '@0x/types';
 import { BigNumber } from '@0x/utils';
 
 const { safeAdd, safeSub, safeMul, safeDiv } = ReferenceFunctions;
@@ -94,7 +94,7 @@ export function addFillResults(a: FillResults, b: FillResults): FillResults {
  * Calculates amounts filled and fees paid by maker and taker.
  */
 export function calculateFillResults(
-    order: OrderWithoutDomain,
+    order: Order,
     takerAssetFilledAmount: BigNumber,
     protocolFeeMultiplier: BigNumber,
     gasPrice: BigNumber,

contracts/exchange-libs/test/lib_fill_results.ts

@@ -536,10 +536,8 @@ blockchainTests('LibFillResults', env => {
             feeRecipientAddress: randomAddress(),
             expirationTimeSeconds: randomUint256(),
             salt: randomUint256(),
-            domain: {
+            exchangeAddress: constants.NULL_ADDRESS,
-                verifyingContract: constants.NULL_ADDRESS,
             chainId: 1337, // The chain id for the isolated exchange
-            },
         };
 
         function makeOrder(details?: Partial<Order>): Order {
@@ -547,7 +545,7 @@ blockchainTests('LibFillResults', env => {
         }
 
         before(async () => {
-            ORDER_DEFAULTS.domain.verifyingContract = libsContract.address;
+            ORDER_DEFAULTS.exchangeAddress = libsContract.address;
         });
 
         it('should correctly calculate the results when only the right order is fully filled', async () => {
@@ -1209,10 +1207,8 @@ blockchainTests('LibFillResults', env => {
             feeRecipientAddress: randomAddress(),
             expirationTimeSeconds: randomUint256(),
             salt: randomUint256(),
-            domain: {
+            exchangeAddress: constants.NULL_ADDRESS,
-                verifyingContract: constants.NULL_ADDRESS,
             chainId: 1337, // The chain id for the isolated exchange
-            },
         };
 
         function makeOrder(details?: Partial<Order>): Order {
@@ -1220,7 +1216,7 @@ blockchainTests('LibFillResults', env => {
         }
 
         before(async () => {
-            ORDER_DEFAULTS.domain.verifyingContract = libsContract.address;
+            ORDER_DEFAULTS.exchangeAddress = libsContract.address;
         });
 
         it('should transfer correct amounts when right order is fully filled', async () => {

contracts/exchange-libs/test/lib_order.ts

@@ -16,10 +16,8 @@ blockchainTests('LibOrder', env => {
     const randomAssetData = () => hexRandom(36);
 
     const EMPTY_ORDER: Order = {
-        domain: {
+        exchangeAddress: constants.NULL_ADDRESS,
-            verifyingContract: constants.NULL_ADDRESS,
         chainId: 0,
-        },
         senderAddress: constants.NULL_ADDRESS,
         makerAddress: constants.NULL_ADDRESS,
         takerAddress: constants.NULL_ADDRESS,
@@ -52,7 +50,8 @@ blockchainTests('LibOrder', env => {
         const expectedHash = orderHashUtils.getOrderHashHex(order);
         const domainHash = ethUtil.bufferToHex(
             signTypedDataUtils.generateDomainHash({
-                ...order.domain,
+                chainId: order.chainId,
+                exchangeAddress: order.exchangeAddress,
                 name: constants.EIP712_DOMAIN_NAME,
                 version: constants.EIP712_DOMAIN_VERSION,
             }),
@@ -65,19 +64,14 @@ blockchainTests('LibOrder', env => {
         it('should correctly hash an empty order', async () => {
             await testGetTypedDataHashAsync({
                 ...EMPTY_ORDER,
-                domain: {
+                exchangeAddress: libOrderContract.address,
-                    ...EMPTY_ORDER.domain,
-                    verifyingContract: libOrderContract.address,
-                },
             });
         });
 
         it('should correctly hash a non-empty order', async () => {
             await testGetTypedDataHashAsync({
-                domain: {
+                exchangeAddress: libOrderContract.address,
-                    verifyingContract: libOrderContract.address,
                 chainId: 1337,
-                },
                 senderAddress: randomAddress(),
                 makerAddress: randomAddress(),
                 takerAddress: randomAddress(),
@@ -98,14 +92,15 @@ blockchainTests('LibOrder', env => {
         it('orderHash should differ if the domain hash is different', async () => {
             const domainHash1 = ethUtil.bufferToHex(
                 signTypedDataUtils.generateDomainHash({
-                    ...EMPTY_ORDER.domain,
+                    chainId: EMPTY_ORDER.chainId,
+                    exchangeAddress: EMPTY_ORDER.exchangeAddress,
                     name: constants.EIP712_DOMAIN_NAME,
                     version: constants.EIP712_DOMAIN_VERSION,
                 }),
             );
             const domainHash2 = ethUtil.bufferToHex(
                 signTypedDataUtils.generateDomainHash({
-                    ...EMPTY_ORDER.domain,
+                    exchangeAddress: EMPTY_ORDER.exchangeAddress,
                     name: constants.EIP712_DOMAIN_NAME,
                     version: constants.EIP712_DOMAIN_VERSION,
                     chainId: 1337,
@@ -135,10 +130,8 @@ blockchainTests('LibOrder', env => {
         it('should correctly hash a non-empty order', async () => {
             await testGetStructHashAsync({
                 // The domain is not used in this test, so it's okay if it is left empty.
-                domain: {
+                exchangeAddress: constants.NULL_ADDRESS,
-                    verifyingContract: constants.NULL_ADDRESS,
                 chainId: 0,
-                },
                 senderAddress: randomAddress(),
                 makerAddress: randomAddress(),
                 takerAddress: randomAddress(),

contracts/exchange/test/core.ts

@@ -217,10 +217,8 @@ blockchainTests.resets('Exchange core', () => {
             takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerAssetAddress),
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
-            domain: {
+            exchangeAddress: exchange.address,
-                verifyingContract: exchange.address,
             chainId,
-            },
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

contracts/exchange/test/internal.ts

@@ -56,10 +56,8 @@ blockchainTests('Exchange core internal functions', env => {
             salt: new BigNumber(_.random(0, 1e8)),
             feeRecipientAddress: randomAddress(),
             expirationTimeSeconds: new BigNumber(_.random(0, 1e8)),
-            domain: {
+            exchangeAddress: constants.NULL_ADDRESS,
-                verifyingContract: constants.NULL_ADDRESS,
             chainId: 1337, // The chain id for the isolated exchange
-            },
         };
 
         function makeOrder(details?: Partial<Order>): Order {
@@ -67,7 +65,7 @@ blockchainTests('Exchange core internal functions', env => {
         }
 
         before(async () => {
-            ORDER_DEFAULTS.domain.verifyingContract = testExchange.address;
+            ORDER_DEFAULTS.exchangeAddress = testExchange.address;
         });
 
         it('should revert if the maker asset multiplication should overflow', async () => {

contracts/exchange/test/match_orders.ts

@@ -198,10 +198,7 @@ describe('matchOrders', () => {
         defaultFeeTokenAddress = erc20Tokens[2].address;
         defaultERC721AssetAddress = erc721Token.address;
         defaultERC1155AssetAddress = erc1155Token.address;
-        const domain = {
+
-            verifyingContract: exchange.address,
-            chainId,
-        };
         // Create default order parameters
         const defaultOrderParamsLeft = {
             ...constants.STATIC_ORDER_PARAMS,
@@ -211,7 +208,8 @@ describe('matchOrders', () => {
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeTokenAddress),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeTokenAddress),
             feeRecipientAddress: feeRecipientAddressLeft,
-            domain,
+            exchangeAddress: exchange.address,
+            chainId,
         };
         const defaultOrderParamsRight = {
             ...constants.STATIC_ORDER_PARAMS,
@@ -221,7 +219,8 @@ describe('matchOrders', () => {
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeTokenAddress),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeTokenAddress),
             feeRecipientAddress: feeRecipientAddressRight,
-            domain,
+            exchangeAddress: exchange.address,
+            chainId,
         };
         const privateKeyLeft = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddressLeft)];
         orderFactoryLeft = new OrderFactory(privateKeyLeft, defaultOrderParamsLeft);

contracts/exchange/test/signature_validator.ts

@@ -435,10 +435,8 @@ blockchainTests.resets('MixinSignatureValidator', env => {
                 takerFeeAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
                 makerFee: constants.ZERO_AMOUNT,
                 takerFee: constants.ZERO_AMOUNT,
-                domain: {
+                exchangeAddress: signatureValidator.address,
-                    verifyingContract: signatureValidator.address,
                 chainId,
-                },
             };
             orderFactory = new OrderFactory(signerPrivateKey, defaultOrderParams);
         });

contracts/exchange/test/transactions.ts

@@ -11,7 +11,7 @@ import {
     TransactionFactory,
 } from '@0x/contracts-test-utils';
 import { assetDataUtils, ExchangeRevertErrors, orderHashUtils, transactionHashUtils } from '@0x/order-utils';
-import { EIP712DomainWithDefaultSchema, FillResults, OrderStatus } from '@0x/types';
+import { FillResults, OrderStatus } from '@0x/types';
 import { AbiEncoder, BigNumber } from '@0x/utils';
 import { LogWithDecodedArgs, MethodAbi } from 'ethereum-types';
 import * as ethUtil from 'ethereumjs-util';
@@ -51,7 +51,6 @@ blockchainTests.resets('Exchange transactions', env => {
     let exchangeInstance: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
 
-    let domain: EIP712DomainWithDefaultSchema;
     let orderFactory: OrderFactory;
     let makerTransactionFactory: TransactionFactory;
     let takerTransactionFactory: TransactionFactory;
@@ -107,11 +106,6 @@ blockchainTests.resets('Exchange transactions', env => {
         defaultMakerFeeTokenAddress = makerFeeToken.address;
         defaultTakerFeeTokenAddress = takerFeeToken.address;
 
-        domain = {
-            verifyingContract: exchangeInstance.address,
-            chainId,
-        };
-
         const defaultOrderParams = {
             ...constants.STATIC_ORDER_PARAMS,
             makerAddress,
@@ -120,7 +114,8 @@ blockchainTests.resets('Exchange transactions', env => {
             takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerTokenAddress),
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultMakerFeeTokenAddress),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerFeeTokenAddress),
-            domain,
+            exchangeAddress: exchangeInstance.address,
+            chainId,
         };
         makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];

contracts/exchange/test/utils/isolated_exchange_wrapper.ts

@@ -101,11 +101,11 @@ export class IsolatedExchangeWrapper {
     }
 
     public getOrderHash(order: Order): string {
-        const domain = {
+        const domainInfo = {
-            verifyingContract: this.instance.address,
+            exchangeAddress: this.instance.address,
             chainId: IsolatedExchangeWrapper.CHAIN_ID,
         };
-        return orderHashUtils.getOrderHashHex({ ...order, domain });
+        return orderHashUtils.getOrderHashHex({ ...order, ...domainInfo });
     }
 
     public async getOrderInfoAsync(order: Order): Promise<OrderInfo> {

contracts/exchange/test/utils/order_factory_from_scenario.ts

@@ -430,10 +430,8 @@ export class OrderFactoryFromScenario {
             salt: generatePseudoRandomSalt(),
             feeRecipientAddress,
             expirationTimeSeconds,
-            domain: {
+            exchangeAddress: this._exchangeAddress,
-                verifyingContract: this._exchangeAddress,
             chainId: this._chainId,
-            },
         };
 
         return order;

contracts/exchange/test/wrapper.ts

@@ -97,10 +97,8 @@ blockchainTests.resets('Exchange wrappers', env => {
             takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerAssetAddress),
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
-            domain: {
+            exchangeAddress: exchange.address,
-                verifyingContract: exchange.address,
             chainId,
-            },
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

contracts/exchange/test/wrapper_unit_tests.ts

@@ -90,10 +90,8 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
     function getExpectedOrderHash(order: Order): string {
         return orderHashUtils.getOrderHashHex({
             ...order,
-            domain: {
+            exchangeAddress: testContract.address,
-                verifyingContract: testContract.address,
             chainId: CHAIN_ID,
-            },
         });
     }
 

contracts/extensions/test/balance_threshold_filter.ts

@@ -177,10 +177,8 @@ describe(ContractName.BalanceThresholdFilter, () => {
             makerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), DECIMALS_DEFAULT),
             takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(150), DECIMALS_DEFAULT),
             senderAddress: erc721BalanceThresholdFilterInstance.address,
-            domain: {
+            exchangeAddress: exchangeInstance.address,
-                verifyingContract: exchangeInstance.address,
             chainId,
-            },
         };
         // Create two order factories with valid makers (who meet the threshold balance), and
         // one factory for an invalid address (that does not meet the threshold balance)

contracts/extensions/test/dutch_auction.ts

@@ -163,10 +163,8 @@ describe(ContractName.DutchAuction, () => {
             expirationTimeSeconds: auctionEndTimeSeconds,
             makerFee: constants.ZERO_AMOUNT,
             takerFee: constants.ZERO_AMOUNT,
-            domain: {
+            exchangeAddress: exchangeInstance.address,
-                verifyingContract: exchangeInstance.address,
             chainId,
-            },
         };
         // Default buy order is for the auction begin price
         const buyerDefaultOrderParams = {

contracts/extensions/test/order_matcher.ts

@@ -166,11 +166,6 @@ describe('OrderMatcher', () => {
             constants.AWAIT_TRANSACTION_MINED_MS,
         );
 
-        const domain = {
-            verifyingContract: exchange.address,
-            chainId,
-        };
-
         // Create default order parameters
         const defaultOrderParamsLeft = {
             ...constants.STATIC_ORDER_PARAMS,
@@ -180,7 +175,8 @@ describe('OrderMatcher', () => {
             feeRecipientAddress: feeRecipientAddressLeft,
             makerFee: constants.ZERO_AMOUNT,
             takerFee: constants.ZERO_AMOUNT,
-            domain,
+            exchangeAddress: exchange.address,
+            chainId,
         };
         const defaultOrderParamsRight = {
             ...constants.STATIC_ORDER_PARAMS,
@@ -190,7 +186,8 @@ describe('OrderMatcher', () => {
             feeRecipientAddress: feeRecipientAddressRight,
             makerFee: constants.ZERO_AMOUNT,
             takerFee: constants.ZERO_AMOUNT,
-            domain,
+            exchangeAddress: exchange.address,
+            chainId,
         };
         const privateKeyLeft = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddressLeft)];
         orderFactoryLeft = new OrderFactory(privateKeyLeft, defaultOrderParamsLeft);

contracts/test-utils/src/order_utils.ts

@@ -31,7 +31,7 @@ export const orderUtils = {
         return cancel;
     },
     getOrderWithoutDomain(signedOrder: SignedOrder): OrderWithoutDomain {
-        return _.omit(signedOrder, ['signature', 'domain']) as OrderWithoutDomain;
+        return _.omit(signedOrder, ['signature', 'exchangeAddress', 'chainId']) as OrderWithoutDomain;
     },
     createBatchMatchOrders(signedOrdersLeft: SignedOrder[], signedOrdersRight: SignedOrder[]): BatchMatchOrder {
         return {

packages/asset-swapper/test/exchange_swap_quote_consumer_test.ts

@@ -82,10 +82,8 @@ describe('ExchangeSwapQuoteConsumer', () => {
             takerAssetData,
             makerFeeAssetData: assetDataUtils.encodeERC20AssetData(contractAddresses.zrxToken),
             takerFeeAssetData: assetDataUtils.encodeERC20AssetData(contractAddresses.zrxToken),
-            domain: {
+            exchangeAddress: contractAddresses.exchange,
-                verifyingContract: contractAddresses.exchange,
             chainId: networkId,
-            },
         };
         const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

packages/connect/test/fixtures/standard_relayer_api/orderbook.ts

@@ -25,10 +25,8 @@ export const orderbookResponse: OrderbookResponse = {
                     makerFeeAssetData: '0xf47261b04c32345ced77393b3530b1eed0f346429d',
                     takerFeeAssetData: '0x0257179264389b814a946f3e92105513705ca6b990',
                     signature: '0x012761a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-                    domain: {
                     chainId: 1,
-                        verifyingContract: '0x12459c951127e0c374ff9105dda097662a027093',
+                    exchangeAddress: '0x12459c951127e0c374ff9105dda097662a027093',
-                    },
                 },
                 metaData: {},
             },
@@ -56,10 +54,8 @@ export const orderbookResponse: OrderbookResponse = {
                     makerFeeAssetData: '0x0257179264389b814a946f3e92105513705ca6b990',
                     takerFeeAssetData: '0xf47261b04c32345ced77393b3530b1eed0f346429d',
                     signature: '0x013842a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b3518891',
-                    domain: {
                     chainId: 1,
-                        verifyingContract: '0x12459c951127e0c374ff9105dda097662a027093',
+                    exchangeAddress: '0x12459c951127e0c374ff9105dda097662a027093',
-                    },
                 },
                 metaData: {},
             },

packages/connect/test/fixtures/standard_relayer_api/orders.ts

@@ -24,10 +24,8 @@ export const ordersResponse: OrdersResponse = {
                 makerFeeAssetData: '0xf47261b04c32345ced77393b3530b1eed0f346429d',
                 takerFeeAssetData: '0x0257179264389b814a946f3e92105513705ca6b990',
                 signature: '0x012761a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-                domain: {
                 chainId: 1,
-                    verifyingContract: '0x12459c951127e0c374ff9105dda097662a027093',
+                exchangeAddress: '0x12459c951127e0c374ff9105dda097662a027093',
-                },
             },
             metaData: {},
         },

packages/contract-wrappers/test/calldata_decoder_test.ts

@@ -39,8 +39,8 @@ describe('ABI Decoding Calldata', () => {
         const [privateKeyLeft, privateKeyRight] = constants.TESTRPC_PRIVATE_KEYS;
         const exchangeAddress = addressUtils.generatePseudoRandomAddress();
         const feeRecipientAddress = addressUtils.generatePseudoRandomAddress();
-        const domain = {
+        const domainInfo = {
-            verifyingContract: exchangeAddress,
+            exchangeAddress,
             chainId,
         };
         // Create orders to match.
@@ -78,9 +78,9 @@ describe('ABI Decoding Calldata', () => {
             salt: new BigNumber(50010),
         };
         const orderFactoryLeft = new OrderFactory(privateKeyLeft, orderLeft);
-        signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync({ domain });
+        signedOrderLeft = await orderFactoryLeft.newSignedOrderAsync(domainInfo);
         const orderFactoryRight = new OrderFactory(privateKeyRight, orderRight);
-        signedOrderRight = await orderFactoryRight.newSignedOrderAsync({ domain });
+        signedOrderRight = await orderFactoryRight.newSignedOrderAsync(domainInfo);
         // Encode match orders transaction
         contractAddresses = await migrateOnceAsync();
         await blockchainLifecycle.startAsync();

packages/contract-wrappers/test/coordinator_wrapper_test.ts

@@ -101,10 +101,8 @@ describe.skip('CoordinatorWrapper', () => {
             makerFeeAssetData: feeAssetData,
             takerFeeAssetData: feeAssetData,
             senderAddress: contractAddresses.coordinator,
-            domain: {
+            exchangeAddress: exchangeContractAddress,
-                verifyingContract: exchangeContractAddress,
             chainId,
-            },
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);

packages/fill-scenarios/src/fill_scenarios.ts

@@ -124,12 +124,12 @@ export class FillScenarios {
             fillableAmount,
         );
         const exchangeInstance = new ExchangeContract(
-            signedOrder.domain.verifyingContract,
+            signedOrder.exchangeAddress,
             this._web3Wrapper.getProvider(),
             this._web3Wrapper.getContractDefaults(),
         );
 
-        const orderWithoutDomain = _.omit(signedOrder, ['signature', 'domain']) as OrderWithoutDomain;
+        const orderWithoutDomain = _.omit(signedOrder, ['signature', 'exchangeAddress', 'chainId']) as OrderWithoutDomain;
 
         const txHash = await exchangeInstance.fillOrder.sendTransactionAsync(
             orderWithoutDomain,

packages/json-schemas/schemas/order_schema.json

@@ -1,21 +1,54 @@
 {
     "id": "/orderSchema",
     "properties": {
-        "makerAddress": { "$ref": "/addressSchema" },
+        "makerAddress": {
-        "takerAddress": { "$ref": "/addressSchema" },
+            "$ref": "/addressSchema"
-        "makerFee": { "$ref": "/wholeNumberSchema" },
+        },
-        "takerFee": { "$ref": "/wholeNumberSchema" },
+        "takerAddress": {
-        "senderAddress": { "$ref": "/addressSchema" },
+            "$ref": "/addressSchema"
-        "makerAssetAmount": { "$ref": "/wholeNumberSchema" },
+        },
-        "takerAssetAmount": { "$ref": "/wholeNumberSchema" },
+        "makerFee": {
-        "makerAssetData": { "$ref": "/hexSchema" },
+            "$ref": "/wholeNumberSchema"
-        "takerAssetData": { "$ref": "/hexSchema" },
+        },
-        "makerFeeAssetData": { "$ref": "/hexSchema" },
+        "takerFee": {
-        "takerFeeAssetData": { "$ref": "/hexSchema" },
+            "$ref": "/wholeNumberSchema"
-        "salt": { "$ref": "/wholeNumberSchema" },
+        },
-        "feeRecipientAddress": { "$ref": "/addressSchema" },
+        "senderAddress": {
-        "expirationTimeSeconds": { "$ref": "/wholeNumberSchema" },
+            "$ref": "/addressSchema"
-        "domain": { "$ref": "/eip712DomainSchema" }
+        },
+        "makerAssetAmount": {
+            "$ref": "/wholeNumberSchema"
+        },
+        "takerAssetAmount": {
+            "$ref": "/wholeNumberSchema"
+        },
+        "makerAssetData": {
+            "$ref": "/hexSchema"
+        },
+        "takerAssetData": {
+            "$ref": "/hexSchema"
+        },
+        "makerFeeAssetData": {
+            "$ref": "/hexSchema"
+        },
+        "takerFeeAssetData": {
+            "$ref": "/hexSchema"
+        },
+        "salt": {
+            "$ref": "/wholeNumberSchema"
+        },
+        "feeRecipientAddress": {
+            "$ref": "/addressSchema"
+        },
+        "expirationTimeSeconds": {
+            "$ref": "/wholeNumberSchema"
+        },
+        "chainId": {
+            "type": "number "
+        },
+        "exchangeAddress": {
+            "$ref": "/addressSchema"
+        }
     },
     "required": [
         "makerAddress",
@@ -32,7 +65,8 @@
         "salt",
         "feeRecipientAddress",
         "expirationTimeSeconds",
-        "domain"
+        "chainId",
+        "exchangeAddress"
     ],
     "type": "object"
 }

packages/json-schemas/test/schema_test.ts

@@ -219,10 +219,8 @@ describe('Schema', () => {
             salt: '67006738228878699843088602623665307406148487219438534730168799356281242528500',
             feeRecipientAddress: NULL_ADDRESS,
             expirationTimeSeconds: '42',
-            domain: {
+            exchangeAddress: NULL_ADDRESS,
-                verifyingContract: NULL_ADDRESS,
             chainId: CHAIN_ID,
-            },
         };
         const relayerApiOrder = {
             order,

packages/order-utils/src/eip712_utils.ts

@@ -59,11 +59,15 @@ export const eip712Utils = {
         const normalizedOrder = _.mapValues(order, value => {
             return !_.isString(value) ? value.toString() : value;
         });
+        const partialDomain = {
+            chainId: order.chainId,
+            verifyingContract: order.exchangeAddress,
+        };
         const typedData = eip712Utils.createTypedData(
             constants.EXCHANGE_ORDER_SCHEMA.name,
             { Order: constants.EXCHANGE_ORDER_SCHEMA.parameters },
             normalizedOrder,
-            order.domain,
+            partialDomain,
         );
         return typedData;
     },

packages/order-utils/src/order_factory.ts

@@ -52,10 +52,8 @@ export const orderFactory = {
             salt: createOrderOpts.salt || defaultCreateOrderOpts.salt,
             expirationTimeSeconds:
                 createOrderOpts.expirationTimeSeconds || defaultCreateOrderOpts.expirationTimeSeconds,
-            domain: {
+            exchangeAddress,
-                verifyingContract: exchangeAddress,
             chainId,
-            },
         };
         return order;
     },
@@ -87,7 +85,7 @@ export const orderFactory = {
 };
 
 function getChainIdFromPartial(partialOrder: Partial<Order> | Partial<SignedOrder>): number {
-    const chainId: number = _.get(partialOrder, ['domain', 'chainId']);
+    const chainId = partialOrder.chainId;
     if (!_.isNumber(chainId)) {
         throw new Error('chainId must be valid');
     }
@@ -117,10 +115,8 @@ function generateEmptyOrder(chainId: number): Order {
         salt: generatePseudoRandomSalt(),
         feeRecipientAddress: constants.NULL_ADDRESS,
         expirationTimeSeconds: constants.INFINITE_TIMESTAMP_SEC,
-        domain: {
+        exchangeAddress: constants.NULL_ADDRESS,
-            verifyingContract: constants.NULL_ADDRESS,
         chainId,
-        },
     };
 }
 

packages/order-utils/test/order_hash_test.ts

@@ -32,10 +32,8 @@ describe('Order hashing', () => {
             makerAssetAmount: new BigNumber(0),
             takerAssetAmount: new BigNumber(0),
             expirationTimeSeconds: new BigNumber(0),
-            domain: {
+            exchangeAddress: fakeExchangeContractAddress,
-                verifyingContract: fakeExchangeContractAddress,
             chainId: fakeChainID,
-            },
         };
         it('calculates the order hash', async () => {
             const orderHash = orderHashUtils.getOrderHashHex(order);

packages/order-utils/test/remaining_fillable_calculator_test.ts

@@ -59,10 +59,8 @@ describe('RemainingFillableCalculator', () => {
             takerFeeAssetData,
             salt: zero,
             expirationTimeSeconds: zero,
-            domain: {
+            exchangeAddress: zeroAddress,
-                verifyingContract: zeroAddress,
             chainId,
-            },
         };
     }
     describe('Maker asset is not fee asset', () => {

packages/order-utils/test/signature_utils_test.ts

@@ -41,10 +41,8 @@ describe('Signature utils', () => {
             makerAssetAmount: new BigNumber(0),
             takerAssetAmount: new BigNumber(0),
             expirationTimeSeconds: new BigNumber(0),
-            domain: {
+            exchangeAddress: fakeExchangeContractAddress,
-                verifyingContract: fakeExchangeContractAddress,
             chainId: fakeChainId,
-            },
         };
         transaction = {
             domain: {

packages/orderbook/test/utils.ts

@@ -10,10 +10,8 @@ export const createOrder = (makerAssetData: string, takerAssetData: string): API
             takerAssetData,
             makerFeeAssetData: makerAssetData,
             takerFeeAssetData: takerAssetData,
-            domain: {
             chainId: 0,
-                verifyingContract: '0x00',
+            exchangeAddress: '0x00',
-            },
             senderAddress: '0x00',
             makerAssetAmount: new BigNumber(1),
             takerAssetAmount: new BigNumber(1),

packages/testnet-faucets/src/ts/handler.ts

@@ -182,10 +182,8 @@ export class Handler {
                 // tslint:disable-next-line:custom-no-magic-numbers
                 .div(1000)
                 .integerValue(BigNumber.ROUND_FLOOR),
-            domain: {
+            exchangeAddress: networkConfig.contractWrappers.exchange.address,
-                verifyingContract: networkConfig.contractWrappers.exchange.address,
             chainId: networkConfig.networkId,
-            },
         };
         const orderHash = orderHashUtils.getOrderHashHex(order);
         const signature = await signatureUtils.ecSignHashAsync(

packages/types/src/index.ts

@@ -3,11 +3,9 @@
 import { BigNumber } from 'bignumber.js';
 import { ContractAbi, ContractNetworks, DevdocOutput } from 'ethereum-types';
 
-// HACK: Rather then extending from OrderWithoutDomain
-// we don't, because our docs don't expand inherited types, and it's unnecessarily
-// confusing to introduce the user to the OrderWithoutDomain type.
 export interface Order {
-    domain: EIP712DomainWithDefaultSchema;
+    chainId: number;
+    exchangeAddress: string;
     makerAddress: string;
     takerAddress: string;
     feeRecipientAddress: string;