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

Addressed review comments and prettified code

Browse Source
This commit is contained in:
Alex Towle 2019-08-13 11:05:37 -07:00
parent 6e1fdda182
commit e4257fb6c7
4 changed files with 85 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
contracts/exchange-libs/test/lib_eip712_exchange_domain.ts
View File

@ -1,6 +1,4 @@
import { blockchainTests, constants, describe, expect, hexRandom } from '@0x/contracts-test-utils'; import { blockchainTests, constants, describe, expect, hexRandom } from '@0x/contracts-test-utils';
import { eip712Utils, orderHashUtils } from '@0x/order-utils';
import { Order } from '@0x/types';
import { BigNumber, signTypedDataUtils } from '@0x/utils'; import { BigNumber, signTypedDataUtils } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -13,7 +11,6 @@ blockchainTests('LibEIP712ExchangeDomain', env => {
const CHAIN_ID = 1337; const CHAIN_ID = 1337;
// Random generator functions // Random generator functions
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH);
const randomHash = () => hexRandom(constants.WORD_LENGTH); const randomHash = () => hexRandom(constants.WORD_LENGTH);
/** /**

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

@ -36,17 +36,14 @@ blockchainTests('LibOrder', env => {
expirationTimeSeconds: constants.ZERO_AMOUNT, expirationTimeSeconds: constants.ZERO_AMOUNT,
}; };
/** before(async () => {
* Tests the `_hashOrder()` function against a reference hash. libsContract = await TestLibsContract.deployFrom0xArtifactAsync(
*/ artifacts.TestLibs,
async function testHashOrderAsync(order: Order): Promise<void> { env.provider,
const typedData = eip712Utils.createOrderTypedData(order); env.txDefaults,
const expectedHash = '0x'.concat( new BigNumber(CHAIN_ID),
signTypedDataUtils.generateTypedDataHashWithoutDomain(typedData).toString('hex'),
); );
const actualHash = await libsContract.hashOrder.callAsync(order); });
expect(actualHash).to.be.eq(expectedHash);
}
/** /**
* Tests the `getOrderHash()` function against a reference hash. * Tests the `getOrderHash()` function against a reference hash.
@ -57,15 +54,6 @@ blockchainTests('LibOrder', env => {
expect(actualHash).to.be.eq(expectedHash); expect(actualHash).to.be.eq(expectedHash);
} }
before(async () => {
libsContract = await TestLibsContract.deployFrom0xArtifactAsync(
artifacts.TestLibs,
env.provider,
env.txDefaults,
new BigNumber(CHAIN_ID),
);
});
describe('getOrderHash', () => { describe('getOrderHash', () => {
it('should correctly hash an empty order', async () => { it('should correctly hash an empty order', async () => {
await testGetOrderHashAsync({ await testGetOrderHashAsync({
@ -101,6 +89,18 @@ blockchainTests('LibOrder', env => {
}); });
}); });
/**
* Tests the `_hashOrder()` function against a reference hash.
*/
async function testHashOrderAsync(order: Order): Promise<void> {
const typedData = eip712Utils.createOrderTypedData(order);
const expectedHash = '0x'.concat(
signTypedDataUtils.generateTypedDataHashWithoutDomain(typedData).toString('hex'),
);
const actualHash = await libsContract.hashOrder.callAsync(order);
expect(actualHash).to.be.eq(expectedHash);
}
describe('hashOrder', () => { describe('hashOrder', () => {
it('should correctly hash an empty order', async () => { it('should correctly hash an empty order', async () => {
await testHashOrderAsync(EMPTY_ORDER); await testHashOrderAsync(EMPTY_ORDER);

42
contracts/exchange-libs/test/lib_zero_ex_transaction.ts
View File

@ -26,17 +26,14 @@ blockchainTests('LibZeroExTransaction', env => {
}, },
}; };
/** before(async () => {
* Tests the `_hashZeroExTransaction()` function against a reference hash. libsContract = await TestLibsContract.deployFrom0xArtifactAsync(
*/ artifacts.TestLibs,
async function testHashZeroExTransactionAsync(transaction: ZeroExTransaction): Promise<void> { env.provider,
const typedData = eip712Utils.createZeroExTransactionTypedData(transaction); env.txDefaults,
const expectedHash = '0x'.concat( new BigNumber(CHAIN_ID),
signTypedDataUtils.generateTypedDataHashWithoutDomain(typedData).toString('hex'),
); );
const actualHash = await libsContract.hashZeroExTransaction.callAsync(transaction); });
expect(actualHash).to.be.eq(expectedHash);
}
/** /**
* Tests the `getTransactionHash()` function against a reference hash. * Tests the `getTransactionHash()` function against a reference hash.
@ -48,15 +45,6 @@ blockchainTests('LibZeroExTransaction', env => {
expect(actualHash).to.be.eq(expectedHash); expect(actualHash).to.be.eq(expectedHash);
} }
before(async () => {
libsContract = await TestLibsContract.deployFrom0xArtifactAsync(
artifacts.TestLibs,
env.provider,
env.txDefaults,
new BigNumber(CHAIN_ID),
);
});
describe('getTransactionHash', () => { describe('getTransactionHash', () => {
it('should correctly hash an empty transaction', async () => { it('should correctly hash an empty transaction', async () => {
await testGetTransactionHashAsync({ await testGetTransactionHashAsync({
@ -82,12 +70,24 @@ blockchainTests('LibZeroExTransaction', env => {
}); });
}); });
/**
* Tests the `_hashZeroExTransaction()` function against a reference hash.
*/
async function testHashZeroExTransactionAsync(transaction: ZeroExTransaction): Promise<void> {
const typedData = eip712Utils.createZeroExTransactionTypedData(transaction);
const expectedHash = '0x'.concat(
signTypedDataUtils.generateTypedDataHashWithoutDomain(typedData).toString('hex'),
);
const actualHash = await libsContract.hashZeroExTransaction.callAsync(transaction);
expect(actualHash).to.be.eq(expectedHash);
}
describe('hashOrder', () => { describe('hashOrder', () => {
it('should correctly hash an empty order', async () => { it('should correctly hash an empty transaction', async () => {
await testHashZeroExTransactionAsync(EMPTY_TRANSACTION); await testHashZeroExTransactionAsync(EMPTY_TRANSACTION);
}); });
it('should correctly hash a non-empty order', async () => { it('should correctly hash a non-empty transaction', async () => {
await testHashZeroExTransactionAsync({ await testHashZeroExTransactionAsync({
salt: randomUint256(), salt: randomUint256(),
expirationTimeSeconds: randomUint256(), expirationTimeSeconds: randomUint256(),

57
contracts/utils/test/lib_eip712.ts
View File

@ -11,6 +11,19 @@ chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
describe('LibEIP712', () => {
let lib: TestLibEIP712Contract;
before(async () => {
await blockchainLifecycle.startAsync();
// Deploy LibEIP712
lib = await TestLibEIP712Contract.deployFrom0xArtifactAsync(artifacts.TestLibEIP712, provider, txDefaults);
});
after(async () => {
await blockchainLifecycle.revertAsync();
});
/** /**
* Tests a specific instance of EIP712 domain hashing. * Tests a specific instance of EIP712 domain hashing.
* @param lib The LibEIP712 contract to call. * @param lib The LibEIP712 contract to call.
@ -20,7 +33,6 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
* @param verifyingContractAddress The verifying contract address of the domain. * @param verifyingContractAddress The verifying contract address of the domain.
*/ */
async function testHashEIP712DomainAsync( async function testHashEIP712DomainAsync(
lib: TestLibEIP712Contract,
name: string, name: string,
version: string, version: string,
chainId: number, chainId: number,
@ -41,17 +53,18 @@ async function testHashEIP712DomainAsync(
expect(actualHash).to.be.eq(hexConcat(expectedHash)); expect(actualHash).to.be.eq(hexConcat(expectedHash));
} }
describe('LibEIP712', () => { describe('_hashEIP712Domain', async () => {
let lib: TestLibEIP712Contract; it('should correctly hash empty input', async () => {
await testHashEIP712DomainAsync('', '', 0, constants.NULL_ADDRESS);
before(async () => {
await blockchainLifecycle.startAsync();
// Deploy LibEIP712
lib = await TestLibEIP712Contract.deployFrom0xArtifactAsync(artifacts.TestLibEIP712, provider, txDefaults);
}); });
after(async () => { it('should correctly hash non-empty input', async () => {
await blockchainLifecycle.revertAsync(); await testHashEIP712DomainAsync('_hashEIP712Domain', '1.0', 62, lib.address);
});
it('should correctly hash non-empty input', async () => {
await testHashEIP712DomainAsync('_hashEIP712Domain', '2.0', 0, lib.address);
});
}); });
/** /**
@ -60,11 +73,7 @@ describe('LibEIP712', () => {
* @param domainHash The hash of the EIP712 domain of this instance. * @param domainHash The hash of the EIP712 domain of this instance.
* @param hashStruct The hash of the struct of this instance. * @param hashStruct The hash of the struct of this instance.
*/ */
async function testHashEIP712MessageAsync( async function testHashEIP712MessageAsync(domainHash: string, hashStruct: string): Promise<void> {
lib: TestLibEIP712Contract,
domainHash: string,
hashStruct: string,
): Promise<void> {
// Remove the hex prefix from the domain hash and the hash struct // Remove the hex prefix from the domain hash and the hash struct
const unprefixedDomainHash = domainHash.slice(2, domainHash.length); const unprefixedDomainHash = domainHash.slice(2, domainHash.length);
const unprefixedHashStruct = hashStruct.slice(2, hashStruct.length); const unprefixedHashStruct = hashStruct.slice(2, hashStruct.length);
@ -80,28 +89,13 @@ describe('LibEIP712', () => {
expect(actualHash).to.be.eq(expectedHash); expect(actualHash).to.be.eq(expectedHash);
} }
describe('_hashEIP712Domain', async () => {
it('should correctly hash empty input', async () => {
await testHashEIP712DomainAsync(lib, '', '', 0, constants.NULL_ADDRESS);
});
it('should correctly hash non-empty input', async () => {
await testHashEIP712DomainAsync(lib, '_hashEIP712Domain', '1.0', 62, lib.address);
});
it('should correctly hash non-empty input', async () => {
await testHashEIP712DomainAsync(lib, '_hashEIP712Domain', '2.0', 0, lib.address);
});
});
describe('_hashEIP712Message', () => { describe('_hashEIP712Message', () => {
it('should correctly hash empty input', async () => { it('should correctly hash empty input', async () => {
await testHashEIP712MessageAsync(lib, constants.NULL_BYTES32, constants.NULL_BYTES32); await testHashEIP712MessageAsync(constants.NULL_BYTES32, constants.NULL_BYTES32);
}); });
it('should correctly hash non-empty input', async () => { it('should correctly hash non-empty input', async () => {
await testHashEIP712MessageAsync( await testHashEIP712MessageAsync(
lib,
'0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6', // keccak256(abi.encode(1)) '0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6', // keccak256(abi.encode(1))
'0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2)) '0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2))
); );
@ -109,7 +103,6 @@ describe('LibEIP712', () => {
it('should correctly hash non-empty input', async () => { it('should correctly hash non-empty input', async () => {
await testHashEIP712MessageAsync( await testHashEIP712MessageAsync(
lib,
'0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2)) '0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace', // keccak256(abi.encode(2))
'0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b', // keccak256(abi.encode(3)) '0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b', // keccak256(abi.encode(3))
); );