crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove domain from Order type

Browse Source
This commit is contained in:
fragosti 2019-09-25 17:15:16 -07:00
parent 23b724dde4
commit 9870f55d24
36 changed files with 184 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
contracts/coordinator/test/coordinator.ts
View File

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

19
contracts/coordinator/test/mixins.ts
View File

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

6
contracts/dev-utils/test/order_validation_utils.ts
View File

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

6
contracts/exchange-forwarder/test/forwarder.ts
View File

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

4
contracts/exchange-libs/src/reference_functions.ts
View File

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

16
contracts/exchange-libs/test/lib_fill_results.ts
View File

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

31
contracts/exchange-libs/test/lib_order.ts
View File

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

6
contracts/exchange/test/core.ts
View File

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

14
contracts/exchange/test/internal.ts
View File

@ -56,10 +56,8 @@ blockchainTests('Exchange core internal functions', env => {
salt: new BigNumber(_.random(0, 1e8)), salt: new BigNumber(_.random(0, 1e8)),
feeRecipientAddress: randomAddress(), feeRecipientAddress: randomAddress(),
expirationTimeSeconds: new BigNumber(_.random(0, 1e8)), expirationTimeSeconds: new BigNumber(_.random(0, 1e8)),
domain: { exchangeAddress: constants.NULL_ADDRESS,
verifyingContract: constants.NULL_ADDRESS, chainId: 1337, // The chain id for the isolated exchange
chainId: 1337, // The chain id for the isolated exchange
},
}; };
function makeOrder(details?: Partial<Order>): Order { function makeOrder(details?: Partial<Order>): Order {
@ -67,7 +65,7 @@ blockchainTests('Exchange core internal functions', env => {
} }
before(async () => { before(async () => {
ORDER_DEFAULTS.domain.verifyingContract = testExchange.address; ORDER_DEFAULTS.exchangeAddress = testExchange.address;
}); });
it('should revert if the maker asset multiplication should overflow', async () => { it('should revert if the maker asset multiplication should overflow', async () => {
@ -292,7 +290,7 @@ blockchainTests('Exchange core internal functions', env => {
); );
const logs = receipt.logs as Array< const logs = receipt.logs as Array<
LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs> LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs>
>; >;
expect(logs.length === 4); expect(logs.length === 4);
expect(_.every(logs, log => log.event === 'DispatchTransferFromCalled')).to.be.true(); expect(_.every(logs, log => log.event === 'DispatchTransferFromCalled')).to.be.true();
// taker -> maker // taker -> maker
@ -472,7 +470,7 @@ blockchainTests('Exchange core internal functions', env => {
); );
const logs = receipt.logs as Array< const logs = receipt.logs as Array<
LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs> LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs>
>; >;
// Ensure that the logs have the correct lengths and names // Ensure that the logs have the correct lengths and names
expect(logs.length).to.be.eq(7); expect(logs.length).to.be.eq(7);
@ -566,7 +564,7 @@ blockchainTests('Exchange core internal functions', env => {
); );
const logs = receipt.logs as Array< const logs = receipt.logs as Array<
LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs> LogWithDecodedArgs<TestExchangeInternalsDispatchTransferFromCalledEventArgs>
>; >;
// Ensure that the logs have the correct lengths and names // Ensure that the logs have the correct lengths and names
expect(logs.length).to.be.eq(8); expect(logs.length).to.be.eq(8);

11
contracts/exchange/test/match_orders.ts
View File

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

10
contracts/exchange/test/signature_validator.ts
View File

@ -435,10 +435,8 @@ blockchainTests.resets('MixinSignatureValidator', env => {
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()), takerFeeAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
makerFee: constants.ZERO_AMOUNT, makerFee: constants.ZERO_AMOUNT,
takerFee: constants.ZERO_AMOUNT, takerFee: constants.ZERO_AMOUNT,
domain: { exchangeAddress: signatureValidator.address,
verifyingContract: signatureValidator.address, chainId,
chainId,
},
}; };
orderFactory = new OrderFactory(signerPrivateKey, defaultOrderParams); orderFactory = new OrderFactory(signerPrivateKey, defaultOrderParams);
}); });
@ -1148,7 +1146,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
expect(res.logs.length).to.equal(1); expect(res.logs.length).to.equal(1);
const log = signatureValidatorLogDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs< const log = signatureValidatorLogDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<
TestSignatureValidatorSignatureValidatorApprovalEventArgs TestSignatureValidatorSignatureValidatorApprovalEventArgs
>; >;
const logArgs = log.args; const logArgs = log.args;
expect(logArgs.signerAddress).to.equal(signerAddress); expect(logArgs.signerAddress).to.equal(signerAddress);
expect(logArgs.validatorAddress).to.equal(validatorWallet.address); expect(logArgs.validatorAddress).to.equal(validatorWallet.address);
@ -1166,7 +1164,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
expect(res.logs.length).to.equal(1); expect(res.logs.length).to.equal(1);
const log = signatureValidatorLogDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs< const log = signatureValidatorLogDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<
TestSignatureValidatorSignatureValidatorApprovalEventArgs TestSignatureValidatorSignatureValidatorApprovalEventArgs
>; >;
const logArgs = log.args; const logArgs = log.args;
expect(logArgs.signerAddress).to.equal(signerAddress); expect(logArgs.signerAddress).to.equal(signerAddress);
expect(logArgs.validatorAddress).to.equal(validatorWallet.address); expect(logArgs.validatorAddress).to.equal(validatorWallet.address);

33
contracts/exchange/test/transactions.ts
View File

@ -11,7 +11,7 @@ import {
TransactionFactory, TransactionFactory,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { assetDataUtils, ExchangeRevertErrors, orderHashUtils, transactionHashUtils } from '@0x/order-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 { AbiEncoder, BigNumber } from '@0x/utils';
import { LogWithDecodedArgs, MethodAbi } from 'ethereum-types'; import { LogWithDecodedArgs, MethodAbi } from 'ethereum-types';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
@ -51,7 +51,6 @@ blockchainTests.resets('Exchange transactions', env => {
let exchangeInstance: ExchangeContract; let exchangeInstance: ExchangeContract;
let erc20Proxy: ERC20ProxyContract; let erc20Proxy: ERC20ProxyContract;
let domain: EIP712DomainWithDefaultSchema;
let orderFactory: OrderFactory; let orderFactory: OrderFactory;
let makerTransactionFactory: TransactionFactory; let makerTransactionFactory: TransactionFactory;
let takerTransactionFactory: TransactionFactory; let takerTransactionFactory: TransactionFactory;
@ -107,11 +106,6 @@ blockchainTests.resets('Exchange transactions', env => {
defaultMakerFeeTokenAddress = makerFeeToken.address; defaultMakerFeeTokenAddress = makerFeeToken.address;
defaultTakerFeeTokenAddress = takerFeeToken.address; defaultTakerFeeTokenAddress = takerFeeToken.address;
domain = {
verifyingContract: exchangeInstance.address,
chainId,
};
const defaultOrderParams = { const defaultOrderParams = {
...constants.STATIC_ORDER_PARAMS, ...constants.STATIC_ORDER_PARAMS,
makerAddress, makerAddress,
@ -120,7 +114,8 @@ blockchainTests.resets('Exchange transactions', env => {
takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerTokenAddress), takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerTokenAddress),
makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultMakerFeeTokenAddress), makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultMakerFeeTokenAddress),
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerFeeTokenAddress), takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerFeeTokenAddress),
domain, exchangeAddress: exchangeInstance.address,
chainId,
}; };
makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)]; makerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)]; takerPrivateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(takerAddress)];
@ -146,7 +141,7 @@ blockchainTests.resets('Exchange transactions', env => {
expect(transactionExecutionLogs.length).to.eq(1); expect(transactionExecutionLogs.length).to.eq(1);
const executionLogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs< const executionLogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(executionLogArgs.transactionHash).to.equal( expect(executionLogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction), transactionHashUtils.getTransactionHashHex(transaction),
); );
@ -611,7 +606,7 @@ blockchainTests.resets('Exchange transactions', env => {
expect(validatorApprovalLogs.length).to.eq(1); expect(validatorApprovalLogs.length).to.eq(1);
const validatorApprovalLogArgs = (validatorApprovalLogs[0] as LogWithDecodedArgs< const validatorApprovalLogArgs = (validatorApprovalLogs[0] as LogWithDecodedArgs<
ExchangeSignatureValidatorApprovalEventArgs ExchangeSignatureValidatorApprovalEventArgs
>).args; >).args;
expect(validatorApprovalLogArgs.signerAddress).to.eq(takerAddress); expect(validatorApprovalLogArgs.signerAddress).to.eq(takerAddress);
expect(validatorApprovalLogArgs.validatorAddress).to.eq(validatorAddress); expect(validatorApprovalLogArgs.validatorAddress).to.eq(validatorAddress);
expect(validatorApprovalLogArgs.isApproved).to.eq(shouldApprove); expect(validatorApprovalLogArgs.isApproved).to.eq(shouldApprove);
@ -633,7 +628,7 @@ blockchainTests.resets('Exchange transactions', env => {
expect(validatorApprovalLogs.length).to.eq(1); expect(validatorApprovalLogs.length).to.eq(1);
const validatorApprovalLogArgs = (validatorApprovalLogs[0] as LogWithDecodedArgs< const validatorApprovalLogArgs = (validatorApprovalLogs[0] as LogWithDecodedArgs<
ExchangeSignatureValidatorApprovalEventArgs ExchangeSignatureValidatorApprovalEventArgs
>).args; >).args;
expect(validatorApprovalLogArgs.signerAddress).to.eq(takerAddress); expect(validatorApprovalLogArgs.signerAddress).to.eq(takerAddress);
expect(validatorApprovalLogArgs.validatorAddress).to.eq(validatorAddress); expect(validatorApprovalLogArgs.validatorAddress).to.eq(validatorAddress);
expect(validatorApprovalLogArgs.isApproved).to.eq(shouldApprove); expect(validatorApprovalLogArgs.isApproved).to.eq(shouldApprove);
@ -661,14 +656,14 @@ blockchainTests.resets('Exchange transactions', env => {
const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs< const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution1LogArgs.transactionHash).to.equal( expect(execution1LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction1), transactionHashUtils.getTransactionHashHex(transaction1),
); );
const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs< const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution2LogArgs.transactionHash).to.equal( expect(execution2LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction2), transactionHashUtils.getTransactionHashHex(transaction2),
); );
@ -727,14 +722,14 @@ blockchainTests.resets('Exchange transactions', env => {
const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs< const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution1LogArgs.transactionHash).to.equal( expect(execution1LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction1), transactionHashUtils.getTransactionHashHex(transaction1),
); );
const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs< const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution2LogArgs.transactionHash).to.equal( expect(execution2LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction2), transactionHashUtils.getTransactionHashHex(transaction2),
); );
@ -792,14 +787,14 @@ blockchainTests.resets('Exchange transactions', env => {
const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs< const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution1LogArgs.transactionHash).to.equal( expect(execution1LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction1), transactionHashUtils.getTransactionHashHex(transaction1),
); );
const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs< const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution2LogArgs.transactionHash).to.equal( expect(execution2LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction2), transactionHashUtils.getTransactionHashHex(transaction2),
); );
@ -886,14 +881,14 @@ blockchainTests.resets('Exchange transactions', env => {
const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs< const execution1LogArgs = (transactionExecutionLogs[0] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution1LogArgs.transactionHash).to.equal( expect(execution1LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction1), transactionHashUtils.getTransactionHashHex(transaction1),
); );
const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs< const execution2LogArgs = (transactionExecutionLogs[1] as LogWithDecodedArgs<
ExchangeTransactionExecutionEventArgs ExchangeTransactionExecutionEventArgs
>).args; >).args;
expect(execution2LogArgs.transactionHash).to.equal( expect(execution2LogArgs.transactionHash).to.equal(
transactionHashUtils.getTransactionHashHex(transaction2), transactionHashUtils.getTransactionHashHex(transaction2),
); );

16
contracts/exchange/test/utils/isolated_exchange_wrapper.ts
View File

@ -101,11 +101,11 @@ export class IsolatedExchangeWrapper {
} }
public getOrderHash(order: Order): string { public getOrderHash(order: Order): string {
const domain = { const domainInfo = {
verifyingContract: this.instance.address, exchangeAddress: this.instance.address,
chainId: IsolatedExchangeWrapper.CHAIN_ID, chainId: IsolatedExchangeWrapper.CHAIN_ID,
}; };
return orderHashUtils.getOrderHashHex({ ...order, domain }); return orderHashUtils.getOrderHashHex({ ...order, ...domainInfo });
} }
public async getOrderInfoAsync(order: Order): Promise<OrderInfo> { public async getOrderInfoAsync(order: Order): Promise<OrderInfo> {
@ -126,11 +126,11 @@ export class IsolatedExchangeWrapper {
TCallAsyncArgs extends any[], TCallAsyncArgs extends any[],
TAwaitTransactionSuccessAsyncArgs extends any[], TAwaitTransactionSuccessAsyncArgs extends any[],
TResult TResult
>( >(
contractFunction: MutatorContractFunction<TCallAsyncArgs, TAwaitTransactionSuccessAsyncArgs, TResult>, contractFunction: MutatorContractFunction<TCallAsyncArgs, TAwaitTransactionSuccessAsyncArgs, TResult>,
// tslint:disable-next-line: trailing-comma // tslint:disable-next-line: trailing-comma
...args: TAwaitTransactionSuccessAsyncArgs ...args: TAwaitTransactionSuccessAsyncArgs
): Promise<TResult> { ): Promise<TResult> {
this.lastTxEvents = createEmptyEvents(); this.lastTxEvents = createEmptyEvents();
this.lastTxBalanceChanges = {}; this.lastTxBalanceChanges = {};
const [result, receipt] = await this.txHelper.getResultAndReceiptAsync(contractFunction, ...args); const [result, receipt] = await this.txHelper.getResultAndReceiptAsync(contractFunction, ...args);

6
contracts/exchange/test/utils/order_factory_from_scenario.ts
View File

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

14
contracts/exchange/test/wrapper.ts
View File

@ -97,10 +97,8 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerAssetAddress), takerAssetData: assetDataUtils.encodeERC20AssetData(defaultTakerAssetAddress),
makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress), makerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress), takerFeeAssetData: assetDataUtils.encodeERC20AssetData(defaultFeeAssetAddress),
domain: { exchangeAddress: exchange.address,
verifyingContract: exchange.address, chainId,
chainId,
},
}; };
const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)]; const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
orderFactory = new OrderFactory(privateKey, defaultOrderParams); orderFactory = new OrderFactory(privateKey, defaultOrderParams);
@ -607,7 +605,7 @@ blockchainTests.resets('Exchange wrappers', env => {
protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid), protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid),
}), }),
nullFillResults, nullFillResults,
); );
expect(fillResults).to.deep.equal(expectedFillResults); expect(fillResults).to.deep.equal(expectedFillResults);
expect(newBalances).to.be.deep.equal(erc20Balances); expect(newBalances).to.be.deep.equal(erc20Balances);
@ -683,7 +681,7 @@ blockchainTests.resets('Exchange wrappers', env => {
protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid), protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid),
}), }),
nullFillResults, nullFillResults,
); );
expect(fillResults).to.deep.equal(expectedFillResults); expect(fillResults).to.deep.equal(expectedFillResults);
expect(newBalances).to.be.deep.equal(erc20Balances); expect(newBalances).to.be.deep.equal(erc20Balances);
@ -799,7 +797,7 @@ blockchainTests.resets('Exchange wrappers', env => {
protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid), protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid),
}), }),
nullFillResults, nullFillResults,
); );
expect(fillResults).to.deep.equal(expectedFillResults); expect(fillResults).to.deep.equal(expectedFillResults);
expect(newBalances).to.be.deep.equal(erc20Balances); expect(newBalances).to.be.deep.equal(erc20Balances);
@ -876,7 +874,7 @@ blockchainTests.resets('Exchange wrappers', env => {
protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid), protocolFeePaid: totalFillResults.protocolFeePaid.plus(currentFillResults.protocolFeePaid),
}), }),
nullFillResults, nullFillResults,
); );
expect(fillResults).to.deep.equal(expectedFillResults); expect(fillResults).to.deep.equal(expectedFillResults);
expect(newBalances).to.be.deep.equal(erc20Balances); expect(newBalances).to.be.deep.equal(erc20Balances);

6
contracts/exchange/test/wrapper_unit_tests.ts
View File

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

6
contracts/extensions/test/balance_threshold_filter.ts
View File

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

6
contracts/extensions/test/dutch_auction.ts
View File

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

11
contracts/extensions/test/order_matcher.ts
View File

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

2
contracts/test-utils/src/order_utils.ts
View File

@ -31,7 +31,7 @@ export const orderUtils = {
return cancel; return cancel;
}, },
getOrderWithoutDomain(signedOrder: SignedOrder): OrderWithoutDomain { 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 { createBatchMatchOrders(signedOrdersLeft: SignedOrder[], signedOrdersRight: SignedOrder[]): BatchMatchOrder {
return { return {

6
packages/asset-swapper/test/exchange_swap_quote_consumer_test.ts
View File

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

12
packages/connect/test/fixtures/standard_relayer_api/orderbook.ts vendored
View File

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

6
packages/connect/test/fixtures/standard_relayer_api/orders.ts vendored
View File

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

8
packages/contract-wrappers/test/calldata_decoder_test.ts
View File

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

6
packages/contract-wrappers/test/coordinator_wrapper_test.ts
View File

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

4
packages/fill-scenarios/src/fill_scenarios.ts
View File

@ -124,12 +124,12 @@ export class FillScenarios {
fillableAmount, fillableAmount,
); );
const exchangeInstance = new ExchangeContract( const exchangeInstance = new ExchangeContract(
signedOrder.domain.verifyingContract, signedOrder.exchangeAddress,
this._web3Wrapper.getProvider(), this._web3Wrapper.getProvider(),
this._web3Wrapper.getContractDefaults(), 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( const txHash = await exchangeInstance.fillOrder.sendTransactionAsync(
orderWithoutDomain, orderWithoutDomain,

66
packages/json-schemas/schemas/order_schema.json
View File

@ -1,21 +1,54 @@
{ {
"id": "/orderSchema", "id": "/orderSchema",
"properties": { "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": [ "required": [
"makerAddress", "makerAddress",
@ -32,7 +65,8 @@
"salt", "salt",
"feeRecipientAddress", "feeRecipientAddress",
"expirationTimeSeconds", "expirationTimeSeconds",
"domain" "chainId",
"exchangeAddress"
], ],
"type": "object" "type": "object"
} }

6
packages/json-schemas/test/schema_test.ts
View File

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

6
packages/order-utils/src/eip712_utils.ts
View File

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

14
packages/order-utils/src/order_factory.ts
View File

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

8
packages/order-utils/test/order_hash_test.ts
View File

@ -32,10 +32,8 @@ describe('Order hashing', () => {
makerAssetAmount: new BigNumber(0), makerAssetAmount: new BigNumber(0),
takerAssetAmount: new BigNumber(0), takerAssetAmount: new BigNumber(0),
expirationTimeSeconds: new BigNumber(0), expirationTimeSeconds: new BigNumber(0),
domain: { exchangeAddress: fakeExchangeContractAddress,
verifyingContract: fakeExchangeContractAddress, chainId: fakeChainID,
chainId: fakeChainID,
},
}; };
it('calculates the order hash', async () => { it('calculates the order hash', async () => {
const orderHash = orderHashUtils.getOrderHashHex(order); const orderHash = orderHashUtils.getOrderHashHex(order);
@ -62,7 +60,7 @@ describe('Order hashing', () => {
}; };
const expectedErrorMessage = `Order taker must be of type string. If you want anyone to be able to fill an order - pass ${ const expectedErrorMessage = `Order taker must be of type string. If you want anyone to be able to fill an order - pass ${
constants.NULL_ADDRESS constants.NULL_ADDRESS
}`; }`;
expect(() => orderHashUtils.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage); expect(() => orderHashUtils.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
}); });
}); });

6
packages/order-utils/test/remaining_fillable_calculator_test.ts
View File

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

6
packages/order-utils/test/signature_utils_test.ts
View File

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

6
packages/orderbook/test/utils.ts
View File

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

6
packages/testnet-faucets/src/ts/handler.ts
View File

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

6
packages/types/src/index.ts
View File

@ -3,11 +3,9 @@
import { BigNumber } from 'bignumber.js'; import { BigNumber } from 'bignumber.js';
import { ContractAbi, ContractNetworks, DevdocOutput } from 'ethereum-types'; 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 { export interface Order {
domain: EIP712DomainWithDefaultSchema; chainId: number;
exchangeAddress: string;
makerAddress: string; makerAddress: string;
takerAddress: string; takerAddress: string;
feeRecipientAddress: string; feeRecipientAddress: string;