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

@0x/order-utils refactors for v3: orderParsingUtils, signatureUtils, orderHashUtils, RevertErrors, transactionHashUtils (#2321)

Browse Source 
* move orderParsingUtils from order-utils to connect

* Remove many functions from signatureUtils

Removed from the exported object, that is.  All of them are used in
other existing code, so they were all moved to be as local to their
usage as possible.

* remove orderHashUtils.isValidOrderHash()

* Move all *RevertErrors from order-utils...

...into their respective @0x/contracts- packages.

* Refactor @0x/order-utils' orderHashUtils away

- Move existing routines into @0x/contracts-test-utils

- Migrate non-contract-test callers to a newly-exposed getOrderHash()
method in DevUtils.

* Move all *RevertErrors from @0x/utils...

...into their respective @0x/contracts- packages.

* rm transactionHashUtils.isValidTransactionHash()

* DevUtils.sol: Fail yarn test if too big to deploy

* Refactor @0x/order-utils transactionHashUtils away

- Move existing routines into @0x/contracts-test-utils

- Migrate non-contract-test callers to a newly-exposed
getTransactionHash() method in DevUtils.

* Consolidate `Removed export...` CHANGELOG entries

* Rm EthBalanceChecker from devutils wrapper exports

* Stop importing from '.' or '.../src'

* fix builds

* fix prettier; dangling promise

* increase max bundle size
This commit is contained in:
F. Eugene Aumson
2019-11-14 17:14:24 -05:00
committed by GitHub
parent f0d7d10fe7
commit f11d8a5bd8
132 changed files with 584 additions and 653 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,4 +1,5 @@
import { assert } from '@0x/assert';
import { DevUtilsContract } from '@0x/contracts-dev-utils';
import { Order, SignatureType, ZeroExTransaction } from '@0x/types';
import { BigNumber } from '@0x/utils';
import * as chai from 'chai';
@@ -7,9 +8,9 @@ import * as ethUtil from 'ethereumjs-util';
import * as _ from 'lodash';
import 'mocha';
import { generatePseudoRandomSalt, orderHashUtils, transactionHashUtils } from '../src';
import { generatePseudoRandomSalt } from '../src';
import { constants } from '../src/constants';
import { signatureUtils } from '../src/signature_utils';
import { isValidECSignature, signatureUtils } from '../src/signature_utils';
import { chaiSetup } from './utils/chai_setup';
import { provider, web3Wrapper } from './utils/web3_wrapper';
@@ -17,6 +18,10 @@ import { provider, web3Wrapper } from './utils/web3_wrapper';
chaiSetup.configure();
const expect = chai.expect;
const devUtilsContract = new DevUtilsContract('0x0000000000000000000000000000000000000000', {
isEIP1193: true,
} as any);
describe('Signature utils', () => {
let makerAddress: string;
const fakeExchangeContractAddress = '0x1dc4c1cefef38a777b15aa20260a54e584b16c48';
@@ -56,78 +61,6 @@ describe('Signature utils', () => {
gasPrice: new BigNumber(0),
};
});
describe('#isValidSignatureAsync', () => {
let dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
const ethSignSignature =
'0x1B61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc3340349190569279751135161d22529dc25add4f6069af05be04cacbda2ace225403';
let address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
it("should return false if the data doesn't pertain to the signature & address", async () => {
const bytes32Zeros = '0x0000000000000000000000000000000000000000000000000000000000000000';
expect(
await signatureUtils.isValidSignatureAsync(provider, bytes32Zeros, ethSignSignature, address),
).to.be.false();
});
it("should return false if the address doesn't pertain to the signature & data", async () => {
const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
expect(
await signatureUtils.isValidSignatureAsync(provider, dataHex, ethSignSignature, validUnrelatedAddress),
).to.be.false();
});
it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
const signatureArray = ethSignSignature.split('');
// tslint:disable-next-line:custom-no-magic-numbers
signatureArray[5] = 'C'; // V = 28, instead of 27
const wrongSignature = signatureArray.join('');
expect(
await signatureUtils.isValidSignatureAsync(provider, dataHex, wrongSignature, address),
).to.be.false();
});
it('should throw if signatureType is invalid', () => {
const signatureArray = ethSignSignature.split('');
signatureArray[3] = '9'; // SignatureType w/ index 9 doesn't exist
const signatureWithInvalidType = signatureArray.join('');
expect(
signatureUtils.isValidSignatureAsync(provider, dataHex, signatureWithInvalidType, address),
).to.be.rejected();
});
it('should return true for a valid Ecrecover (EthSign) signature', async () => {
const isValidSignatureLocal = await signatureUtils.isValidSignatureAsync(
provider,
dataHex,
ethSignSignature,
address,
);
expect(isValidSignatureLocal).to.be.true();
});
it('should return true for a valid EIP712 signature', async () => {
dataHex = '0xa1d7403bcbbcd75ec233cfd6584ff8dabed677d0e9bb32c2bea94e9dd8a109da';
address = '0x6ecbe1db9ef729cbe972c83fb886247691fb6beb';
const eip712Signature =
'0x1bdde07aac4bf12c12ddbb155919c43eba4146a2cfcf904a862950dbebe332554c6674975603eb5a4eaf8fd7f2e06350267e5b36cda9851a89f8bb49fe2fc9afe202';
const isValidSignatureLocal = await signatureUtils.isValidSignatureAsync(
provider,
dataHex,
eip712Signature,
address,
);
expect(isValidSignatureLocal).to.be.true();
});
it('should return false if entry not found in `preSigned` mapping', async () => {
const preSignedSignature = '0x06';
const isValidPreSignature = await signatureUtils.isValidSignatureAsync(
provider,
dataHex,
preSignedSignature,
address,
);
expect(isValidPreSignature).to.be.false();
});
});
describe('#isValidECSignature', () => {
const signature = {
v: 27,
@@ -138,18 +71,18 @@ describe('Signature utils', () => {
const address = '0x0e5cb767cce09a7f3ca594df118aa519be5e2b5a';
it("should return false if the data doesn't pertain to the signature & address", async () => {
expect(signatureUtils.isValidECSignature('0x0', signature, address)).to.be.false();
expect(isValidECSignature('0x0', signature, address)).to.be.false();
});
it("should return false if the address doesn't pertain to the signature & data", async () => {
const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
expect(signatureUtils.isValidECSignature(data, signature, validUnrelatedAddress)).to.be.false();
expect(isValidECSignature(data, signature, validUnrelatedAddress)).to.be.false();
});
it("should return false if the signature doesn't pertain to the data & address", async () => {
const wrongSignature = _.assign({}, signature, { v: 28 });
expect(signatureUtils.isValidECSignature(data, wrongSignature, address)).to.be.false();
expect(isValidECSignature(data, wrongSignature, address)).to.be.false();
});
it('should return true if the signature does pertain to the data & address', async () => {
const isValidSignatureLocal = signatureUtils.isValidECSignature(data, signature, address);
const isValidSignatureLocal = isValidECSignature(data, signature, address);
expect(isValidSignatureLocal).to.be.true();
});
});
@@ -342,23 +275,21 @@ describe('Signature utils', () => {
expect(ecSignature).to.equal(expectedSignature);
});
it('should return a valid signature', async () => {
const expectedSignature =
'0x1b117902c86dfb95fe0d1badd983ee166ad259b27acb220174cbb4460d872871137feabdfe76e05924b484789f79af4ee7fa29ec006cedce1bbf369320d034e10b03';
const orderHash = '0x34decbedc118904df65f379a175bb39ca18209d6ce41d5ed549d54e6e0a95004';
const ecSignature = await signatureUtils.ecSignHashAsync(provider, orderHash, makerAddress);
const isValidSignature = await signatureUtils.isValidSignatureAsync(
provider,
orderHash,
ecSignature,
makerAddress,
);
expect(isValidSignature).to.be.true();
expect(ecSignature).to.equal(expectedSignature);
});
});
describe('#ecSignTypedDataOrderAsync', () => {
it('should result in the same signature as signing the order hash without an ethereum message prefix', async () => {
// Note: Since order hash is an EIP712 hash the result of a valid EIP712 signature
// of order hash is the same as signing the order without the Ethereum Message prefix.
const orderHashHex = orderHashUtils.getOrderHashHex(order);
const orderHashHex = await devUtilsContract
.getOrderHash(order, new BigNumber(order.chainId), order.exchangeAddress)
.callAsync();
const sig = ethUtil.ecsign(
ethUtil.toBuffer(orderHashHex),
Buffer.from('F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D', 'hex'),
@@ -371,14 +302,7 @@ describe('Signature utils', () => {
]);
const signatureHex = `0x${signatureBuffer.toString('hex')}`;
const signedOrder = await signatureUtils.ecSignTypedDataOrderAsync(provider, order, makerAddress);
const isValidSignature = await signatureUtils.isValidSignatureAsync(
provider,
orderHashHex,
signedOrder.signature,
makerAddress,
);
expect(signatureHex).to.eq(signedOrder.signature);
expect(isValidSignature).to.eq(true);
});
it('should return the correct signature for signatureHex concatenated as R + S + V', async () => {
const expectedSignature =
@@ -406,7 +330,13 @@ describe('Signature utils', () => {
it('should result in the same signature as signing the order hash without an ethereum message prefix', async () => {
// Note: Since order hash is an EIP712 hash the result of a valid EIP712 signature
// of order hash is the same as signing the order without the Ethereum Message prefix.
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const transactionHashHex = await devUtilsContract
.getTransactionHash(
transaction,
new BigNumber(transaction.domain.chainId),
transaction.domain.verifyingContract,
)
.callAsync();
const sig = ethUtil.ecsign(
ethUtil.toBuffer(transactionHashHex),
Buffer.from('F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D', 'hex'),
@@ -423,14 +353,7 @@ describe('Signature utils', () => {
transaction,
makerAddress,
);
const isValidSignature = await signatureUtils.isValidSignatureAsync(
provider,
transactionHashHex,
signedTransaction.signature,
makerAddress,
);
expect(signatureHex).to.eq(signedTransaction.signature);
expect(isValidSignature).to.eq(true);
});
it('should return the correct Signature for signatureHex concatenated as R + S + V', async () => {
const fakeProvider = {