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

Remove use of generatePseudoRandomAddress in favor of randomAddress

Browse Source
This commit is contained in:
Amir Bandeali 2019-09-17 10:46:58 -07:00
parent 94738444de
commit bb46f184ed
7 changed files with 42 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
contracts/coordinator/test/libs.ts
View File

@ -1,4 +1,4 @@
import { addressUtils, chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { chaiSetup, constants, provider, randomAddress, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils';
import { transactionHashUtils } from '@0x/order-utils';
import { BigNumber, providerUtils } from '@0x/utils';
@ -13,7 +13,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
describe('Libs tests', () => {
let coordinatorContract: CoordinatorContract;
let chainId: number;
const exchangeAddress = addressUtils.generatePseudoRandomAddress();
const exchangeAddress = randomAddress();
before(async () => {
await blockchainLifecycle.startAsync();

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

@ -1,11 +1,11 @@
import { constants as exchangeConstants, exchangeDataEncoder, ExchangeFunctionName } from '@0x/contracts-exchange';
import {
addressUtils,
chaiSetup,
constants,
expectContractCallFailedAsync,
getLatestBlockTimestampAsync,
provider,
randomAddress,
TransactionFactory,
txDefaults,
web3Wrapper,
@ -33,7 +33,7 @@ describe('Mixins tests', () => {
let approvalFactory1: ApprovalFactory;
let approvalFactory2: ApprovalFactory;
let defaultOrder: SignedOrder;
const exchangeAddress = addressUtils.generatePseudoRandomAddress();
const exchangeAddress = randomAddress();
let exchangeDomain: EIP712DomainWithDefaultSchema;
before(async () => {

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

@ -1,4 +1,4 @@
import { addressUtils, blockchainTests, constants, expect } from '@0x/contracts-test-utils';
import { blockchainTests, constants, expect, randomAddress } from '@0x/contracts-test-utils';
import { BigNumber, signTypedDataUtils } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util';
@ -28,7 +28,7 @@ blockchainTests('LibEIP712ExchangeDomain', env => {
});
it('should calculate the correct domain hash when verifyingContractAddressIfExists is set to a non-null address', async () => {
const chainId = 1;
const verifyingContractAddress = addressUtils.generatePseudoRandomAddress();
const verifyingContractAddress = randomAddress();
const libEIP712ExchangeDomainContract = await TestLibEIP712ExchangeDomainContract.deployFrom0xArtifactAsync(
artifacts.TestLibEIP712ExchangeDomain,
env.provider,

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

@ -1,11 +1,11 @@
import {
addressUtils,
blockchainTests,
constants,
expect,
hexRandom,
OrderStatus,
orderUtils,
randomAddress,
} from '@0x/contracts-test-utils';
import { ExchangeRevertErrors, generatePseudoRandomSalt } from '@0x/order-utils';
import { BigNumber, RevertError } from '@0x/utils';
@ -59,8 +59,8 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
(() => {
const errorCode = ExchangeRevertErrors.SignatureErrorCode.Illegal;
const orderHash = orderUtils.generatePseudoRandomOrderHash();
const signer = addressUtils.generatePseudoRandomAddress();
const validator = addressUtils.generatePseudoRandomAddress();
const signer = randomAddress();
const validator = randomAddress();
const data = hexRandom(ERROR_DATA_LENGTH);
const signature = hexRandom(SIGNATURE_LENGTH);
const errorData = hexRandom(ERROR_DATA_LENGTH);
@ -78,7 +78,7 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
(() => {
const orderHash = orderUtils.generatePseudoRandomOrderHash();
const address = addressUtils.generatePseudoRandomAddress();
const address = randomAddress();
createDecodeTest(ExchangeRevertErrors.ExchangeInvalidContextError, [
ExchangeRevertErrors.ExchangeContextErrorCodes.InvalidMaker,
orderHash,
@ -103,14 +103,14 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
})();
(() => {
const maker = addressUtils.generatePseudoRandomAddress();
const sender = addressUtils.generatePseudoRandomAddress();
const maker = randomAddress();
const sender = randomAddress();
const currentEpoch = generatePseudoRandomSalt();
createDecodeTest(ExchangeRevertErrors.OrderEpochError, [maker, sender, currentEpoch]);
})();
(() => {
const assetProxyAddress = addressUtils.generatePseudoRandomAddress();
const assetProxyAddress = randomAddress();
createDecodeTest(ExchangeRevertErrors.AssetProxyExistsError, [
hexRandom(ASSET_PROXY_ID_LENGTH),
assetProxyAddress,

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

@ -1,5 +1,4 @@
import {
addressUtils,
blockchainTests,
constants,
expect,
@ -8,6 +7,7 @@ import {
LogDecoder,
OrderFactory,
orderUtils,
randomAddress,
TransactionFactory,
} from '@0x/contracts-test-utils';
import {
@ -428,11 +428,11 @@ blockchainTests.resets('MixinSignatureValidator', env => {
const defaultOrderParams = {
...constants.STATIC_ORDER_PARAMS,
makerAddress,
feeRecipientAddress: addressUtils.generatePseudoRandomAddress(),
makerAssetData: assetDataUtils.encodeERC20AssetData(addressUtils.generatePseudoRandomAddress()),
takerAssetData: assetDataUtils.encodeERC20AssetData(addressUtils.generatePseudoRandomAddress()),
makerFeeAssetData: assetDataUtils.encodeERC20AssetData(addressUtils.generatePseudoRandomAddress()),
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(addressUtils.generatePseudoRandomAddress()),
feeRecipientAddress: randomAddress(),
makerAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
takerAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
makerFeeAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(randomAddress()),
makerFee: constants.ZERO_AMOUNT,
takerFee: constants.ZERO_AMOUNT,
domain: {

3
contracts/test-utils/src/address_utils.ts
View File

@ -1,6 +1,9 @@
import { constants } from './constants';
import { hexRandom } from './hex_utils';
/**
* Generates a random address.
*/
export function randomAddress(): string {
return hexRandom(constants.ADDRESS_LENGTH);
}

40
contracts/utils/test/lib_address_array.ts
View File

@ -1,4 +1,4 @@
import { addressUtils, chaiSetup, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { chaiSetup, provider, randomAddress, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils';
import { BigNumber, LibAddressArrayRevertErrors } from '@0x/utils';
import * as chai from 'chai';
@ -29,23 +29,23 @@ describe('LibAddressArray', () => {
describe('append', () => {
it('should append to empty array', async () => {
const addr = addressUtils.generatePseudoRandomAddress();
const addr = randomAddress();
const result = await lib.publicAppend.callAsync([], addr);
const expected = [addr];
expect(result).to.deep.equal(expected);
});
it('should append to non-empty array', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const expected = [...arr, addr];
const result = await lib.publicAppend.callAsync(arr, addr);
expect(result).to.deep.equal(expected);
});
it('should revert if the free memory pointer was moved to before the end of the array', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const freeMemOffset = new BigNumber(-1);
const addressArrayEndPtr = new BigNumber(256);
const expectedError = new LibAddressArrayRevertErrors.MismanagedMemoryError(
@ -56,8 +56,8 @@ describe('LibAddressArray', () => {
});
it('should keep the same memory address if free memory pointer does not move', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const freeMemOffset = new BigNumber(0);
const expected = [...arr, addr];
const [result, oldArrayMemStart, newArrayMemStart] = await lib.testAppendRealloc.callAsync(
@ -70,8 +70,8 @@ describe('LibAddressArray', () => {
});
it('should change memory address if free memory pointer advances', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const freeMemOffset = new BigNumber(1);
const expectedArray = [...arr, addr];
const [result, oldArrayMemStart, newArrayMemStart] = await lib.testAppendRealloc.callAsync(
@ -88,27 +88,27 @@ describe('LibAddressArray', () => {
describe('contains', () => {
it('should return false on an empty array', async () => {
const addr = addressUtils.generatePseudoRandomAddress();
const addr = randomAddress();
const isFound = await lib.publicContains.callAsync([], addr);
expect(isFound).to.equal(false);
});
it('should return false on a missing item', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const isFound = await lib.publicContains.callAsync(arr, addr);
expect(isFound).to.equal(false);
});
it('should return true on an included item', async () => {
const arr = _.times(4, () => addressUtils.generatePseudoRandomAddress());
const arr = _.times(4, () => randomAddress());
const addr = _.sample(arr) as string;
const isFound = await lib.publicContains.callAsync(arr, addr);
expect(isFound).to.equal(true);
});
it('should return true on the only item in the array', async () => {
const arr = _.times(1, () => addressUtils.generatePseudoRandomAddress());
const arr = _.times(1, () => randomAddress());
const isFound = await lib.publicContains.callAsync(arr, arr[0]);
expect(isFound).to.equal(true);
});
@ -116,20 +116,20 @@ describe('LibAddressArray', () => {
describe('indexOf', () => {
it('should fail on an empty array', async () => {
const addr = addressUtils.generatePseudoRandomAddress();
const addr = randomAddress();
const [isSuccess] = await lib.publicIndexOf.callAsync([], addr);
expect(isSuccess).to.equal(false);
});
it('should fail on a missing item', async () => {
const arr = _.times(3, () => addressUtils.generatePseudoRandomAddress());
const addr = addressUtils.generatePseudoRandomAddress();
const arr = _.times(3, () => randomAddress());
const addr = randomAddress();
const [isSuccess] = await lib.publicIndexOf.callAsync(arr, addr);
expect(isSuccess).to.equal(false);
});
it('should succeed on an included item', async () => {
const arr = _.times(4, () => addressUtils.generatePseudoRandomAddress());
const arr = _.times(4, () => randomAddress());
const expectedIndexOf = _.random(0, arr.length - 1);
const addr = arr[expectedIndexOf];
const [isSuccess, index] = await lib.publicIndexOf.callAsync(arr, addr);
@ -138,7 +138,7 @@ describe('LibAddressArray', () => {
});
it('should succeed on the only item in the array', async () => {
const arr = _.times(1, () => addressUtils.generatePseudoRandomAddress());
const arr = _.times(1, () => randomAddress());
const [isSuccess, index] = await lib.publicIndexOf.callAsync(arr, arr[0]);
expect(isSuccess).to.equal(true);
expect(index).bignumber.to.equal(0);