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

Remove assetDataUtils everywhere (#2373)

Browse Source 
* remove assetDataUtils everywhere

* export IAssetDataContract from @0x/contract-wrappers to allow @0x/instant to decode asset data  synchronously

* export generic function `decodeAssetDataOrThrow` and add ERC20Bridge support

* export `hexUtils` from order-utils instead of contracts-test-utils
This commit is contained in:
Xianny 2019-12-04 13:08:08 -08:00 committed by GitHub
parent b86d19028c
commit fcbcbac889
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
70 changed files with 1498 additions and 1129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
contracts/asset-proxy/test/erc20bridge_proxy.ts
View File

@ -3,15 +3,12 @@ import {
constants, constants,
expect, expect,
getRandomInteger, getRandomInteger,
hexLeftPad,
hexRightPad,
hexSlice,
Numberish, Numberish,
randomAddress, randomAddress,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { AuthorizableRevertErrors } from '@0x/contracts-utils'; import { AuthorizableRevertErrors } from '@0x/contracts-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { AbiEncoder, BigNumber, StringRevertError } from '@0x/utils'; import { AbiEncoder, BigNumber, hexUtils, StringRevertError } from '@0x/utils';
import { DecodedLogs } from 'ethereum-types'; import { DecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -21,7 +18,7 @@ import { ERC20BridgeProxyContract, TestERC20BridgeContract } from './wrappers';
blockchainTests.resets('ERC20BridgeProxy unit tests', env => { blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
const PROXY_ID = AssetProxyId.ERC20Bridge; const PROXY_ID = AssetProxyId.ERC20Bridge;
const BRIDGE_SUCCESS_RETURN_DATA = hexRightPad(PROXY_ID); const BRIDGE_SUCCESS_RETURN_DATA = hexUtils.rightPad(PROXY_ID);
let owner: string; let owner: string;
let badCaller: string; let badCaller: string;
let assetProxy: ERC20BridgeProxyContract; let assetProxy: ERC20BridgeProxyContract;
@ -173,7 +170,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
it('fails if asset data is truncated', async () => { it('fails if asset data is truncated', async () => {
const opts = createTransferFromOpts(); const opts = createTransferFromOpts();
const truncatedAssetData = hexSlice(encodeAssetData(opts.assetData), 0, -1); const truncatedAssetData = hexUtils.slice(encodeAssetData(opts.assetData), 0, -1);
const tx = assetProxy const tx = assetProxy
.transferFrom(truncatedAssetData, opts.from, opts.to, new BigNumber(opts.amount)) .transferFrom(truncatedAssetData, opts.from, opts.to, new BigNumber(opts.amount))
.awaitTransactionSuccessAsync(); .awaitTransactionSuccessAsync();
@ -197,7 +194,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
const tx = transferFromAsync({ const tx = transferFromAsync({
assetData: createAssetData({ assetData: createAssetData({
bridgeData: createBridgeData({ bridgeData: createBridgeData({
returnData: hexLeftPad('0x1'), returnData: hexUtils.leftPad('0x1'),
}), }),
}), }),
}); });
@ -210,7 +207,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
const tx = transferFromAsync({ const tx = transferFromAsync({
assetData: createAssetData({ assetData: createAssetData({
bridgeData: createBridgeData({ bridgeData: createBridgeData({
returnData: hexRightPad('0x1'), returnData: hexUtils.rightPad('0x1'),
}), }),
}), }),
}); });

18
contracts/asset-proxy/test/eth2dai_bridge.ts
View File

@ -4,13 +4,11 @@ import {
expect, expect,
filterLogsToArguments, filterLogsToArguments,
getRandomInteger, getRandomInteger,
hexLeftPad,
hexRandom,
Numberish, Numberish,
randomAddress, randomAddress,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { BigNumber, RawRevertError } from '@0x/utils'; import { BigNumber, hexUtils, RawRevertError } from '@0x/utils';
import { DecodedLogs } from 'ethereum-types'; import { DecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -39,7 +37,9 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
describe('isValidSignature()', () => { describe('isValidSignature()', () => {
it('returns success bytes', async () => { it('returns success bytes', async () => {
const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381'; const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync(); const result = await testContract
.isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
.callAsync();
expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE); expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
}); });
}); });
@ -71,7 +71,7 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
fillAmount: getRandomInteger(1, 100e18), fillAmount: getRandomInteger(1, 100e18),
fromTokenBalance: getRandomInteger(1, 100e18), fromTokenBalance: getRandomInteger(1, 100e18),
toTokentransferRevertReason: '', toTokentransferRevertReason: '',
toTokenTransferReturnData: hexLeftPad(1), toTokenTransferReturnData: hexUtils.leftPad(1),
...opts, ...opts,
}; };
} }
@ -111,7 +111,7 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
_opts.toAddress, _opts.toAddress,
new BigNumber(_opts.amount), new BigNumber(_opts.amount),
// ABI-encode the "from" token address as the bridge data. // ABI-encode the "from" token address as the bridge data.
hexLeftPad(_opts.fromTokenAddress as string), hexUtils.leftPad(_opts.fromTokenAddress as string),
); );
const result = await bridgeTransferFromFn.callAsync(); const result = await bridgeTransferFromFn.callAsync();
const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync(); const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
@ -179,13 +179,13 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
}); });
it('fails if `toTokenAddress.transfer()` returns false', async () => { it('fails if `toTokenAddress.transfer()` returns false', async () => {
const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexLeftPad(0) }); const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexUtils.leftPad(0) });
const tx = withdrawToAsync(opts); const tx = withdrawToAsync(opts);
return expect(tx).to.revertWith(new RawRevertError(hexLeftPad(0))); return expect(tx).to.revertWith(new RawRevertError(hexUtils.leftPad(0)));
}); });
it('succeeds if `toTokenAddress.transfer()` returns true', async () => { it('succeeds if `toTokenAddress.transfer()` returns true', async () => {
await withdrawToAsync({ toTokenTransferReturnData: hexLeftPad(1) }); await withdrawToAsync({ toTokenTransferReturnData: hexUtils.leftPad(1) });
}); });
}); });
}); });

10
contracts/asset-proxy/test/kyber_bridge.ts
View File

@ -3,13 +3,11 @@ import {
constants, constants,
expect, expect,
getRandomInteger, getRandomInteger,
hexLeftPad,
hexRandom,
randomAddress, randomAddress,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { DecodedLogs } from 'ethereum-types'; import { DecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -33,7 +31,9 @@ blockchainTests.resets('KyberBridge unit tests', env => {
describe('isValidSignature()', () => { describe('isValidSignature()', () => {
it('returns success bytes', async () => { it('returns success bytes', async () => {
const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381'; const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync(); const result = await testContract
.isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
.callAsync();
expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE); expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
}); });
}); });
@ -107,7 +107,7 @@ blockchainTests.resets('KyberBridge unit tests', env => {
// Transfer amount. // Transfer amount.
_opts.amount, _opts.amount,
// ABI-encode the input token address as the bridge data. // ABI-encode the input token address as the bridge data.
hexLeftPad(_opts.fromTokenAddress), hexUtils.leftPad(_opts.fromTokenAddress),
); );
const result = await bridgeTransferFromFn.callAsync(); const result = await bridgeTransferFromFn.callAsync();
const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync(); const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();

16
contracts/asset-proxy/test/uniswap_bridge.ts
View File

@ -5,13 +5,11 @@ import {
filterLogs, filterLogs,
filterLogsToArguments, filterLogsToArguments,
getRandomInteger, getRandomInteger,
hexLeftPad,
hexRandom,
Numberish, Numberish,
randomAddress, randomAddress,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { DecodedLogs } from 'ethereum-types'; import { DecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -46,7 +44,9 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
describe('isValidSignature()', () => { describe('isValidSignature()', () => {
it('returns success bytes', async () => { it('returns success bytes', async () => {
const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381'; const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync(); const result = await testContract
.isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
.callAsync();
expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE); expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
}); });
}); });
@ -126,7 +126,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
// The amount to transfer to "to" // The amount to transfer to "to"
new BigNumber(_opts.amount), new BigNumber(_opts.amount),
// ABI-encoded "from" token address. // ABI-encoded "from" token address.
hexLeftPad(_opts.fromTokenAddress), hexUtils.leftPad(_opts.fromTokenAddress),
); );
const result = await bridgeTransferFromFn.callAsync(); const result = await bridgeTransferFromFn.callAsync();
const receipt = await bridgeTransferFromFn.awaitTransactionSuccessAsync(); const receipt = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
@ -208,7 +208,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
randomAddress(), randomAddress(),
randomAddress(), randomAddress(),
getRandomInteger(1, 1e18), getRandomInteger(1, 1e18),
hexLeftPad(randomAddress()), hexUtils.leftPad(randomAddress()),
) )
.awaitTransactionSuccessAsync(); .awaitTransactionSuccessAsync();
return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN'); return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
@ -282,7 +282,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
randomAddress(), randomAddress(),
randomAddress(), randomAddress(),
getRandomInteger(1, 1e18), getRandomInteger(1, 1e18),
hexLeftPad(wethTokenAddress), hexUtils.leftPad(wethTokenAddress),
) )
.awaitTransactionSuccessAsync(); .awaitTransactionSuccessAsync();
return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN'); return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
@ -342,7 +342,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
randomAddress(), randomAddress(),
randomAddress(), randomAddress(),
getRandomInteger(1, 1e18), getRandomInteger(1, 1e18),
hexLeftPad(randomAddress()), hexUtils.leftPad(randomAddress()),
) )
.awaitTransactionSuccessAsync(); .awaitTransactionSuccessAsync();
return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN'); return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');

5
contracts/coordinator/src/approval_factory.ts
View File

@ -1,5 +1,6 @@
import { hexConcat, signingUtils } from '@0x/contracts-test-utils'; import { signingUtils } from '@0x/contracts-test-utils';
import { SignatureType, SignedZeroExTransaction } from '@0x/types'; import { SignatureType, SignedZeroExTransaction } from '@0x/types';
import { hexUtils } from '@0x/utils';
import { hashUtils } from './hash_utils'; import { hashUtils } from './hash_utils';
import { SignedCoordinatorApproval } from './types'; import { SignedCoordinatorApproval } from './types';
@ -27,7 +28,7 @@ export class ApprovalFactory {
const signedApproval = { const signedApproval = {
txOrigin, txOrigin,
transaction, transaction,
signature: hexConcat(signatureBuff), signature: hexUtils.concat(signatureBuff),
}; };
return signedApproval; return signedApproval;
} }

7
contracts/coordinator/src/hash_utils.ts
View File

@ -1,7 +1,6 @@
import { hexConcat } from '@0x/contracts-test-utils';
import { eip712Utils } from '@0x/order-utils'; import { eip712Utils } from '@0x/order-utils';
import { SignedZeroExTransaction } from '@0x/types'; import { SignedZeroExTransaction } from '@0x/types';
import { signTypedDataUtils } from '@0x/utils'; import { hexUtils, signTypedDataUtils } from '@0x/utils';
export const hashUtils = { export const hashUtils = {
async getApprovalHashBufferAsync( async getApprovalHashBufferAsync(
@ -22,7 +21,9 @@ export const hashUtils = {
verifyingContract: string, verifyingContract: string,
txOrigin: string, txOrigin: string,
): Promise<string> { ): Promise<string> {
const hashHex = hexConcat(await hashUtils.getApprovalHashBufferAsync(transaction, verifyingContract, txOrigin)); const hashHex = hexUtils.concat(
await hashUtils.getApprovalHashBufferAsync(transaction, verifyingContract, txOrigin),
);
return hashHex; return hashHex;
}, },
}; };

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

@ -4,15 +4,13 @@ import {
constants, constants,
ExchangeFunctionName, ExchangeFunctionName,
expect, expect,
hexConcat,
hexSlice,
randomAddress, randomAddress,
TransactionFactory, TransactionFactory,
transactionHashUtils, transactionHashUtils,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { LibBytesRevertErrors } from '@0x/contracts-utils'; import { LibBytesRevertErrors } from '@0x/contracts-utils';
import { SignatureType, SignedOrder } from '@0x/types'; import { SignatureType, SignedOrder } from '@0x/types';
import { BigNumber, CoordinatorRevertErrors } from '@0x/utils'; import { BigNumber, CoordinatorRevertErrors, hexUtils } from '@0x/utils';
import { ApprovalFactory } from '../src/approval_factory'; import { ApprovalFactory } from '../src/approval_factory';
@ -89,8 +87,8 @@ blockchainTests.resets('Mixins tests', env => {
it('should revert with with the Illegal signature type', async () => { it('should revert with with the Illegal signature type', async () => {
const data = constants.NULL_BYTES; const data = constants.NULL_BYTES;
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
transaction.signature = hexConcat( transaction.signature = hexUtils.concat(
hexSlice(transaction.signature, 0, transaction.signature.length - 1), hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
SignatureType.Illegal, SignatureType.Illegal,
); );
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@ -105,7 +103,7 @@ blockchainTests.resets('Mixins tests', env => {
it('should revert with with the Invalid signature type', async () => { it('should revert with with the Invalid signature type', async () => {
const data = constants.NULL_BYTES; const data = constants.NULL_BYTES;
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
transaction.signature = hexConcat(SignatureType.Invalid); transaction.signature = hexUtils.concat(SignatureType.Invalid);
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith( expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
new CoordinatorRevertErrors.SignatureError( new CoordinatorRevertErrors.SignatureError(
@ -118,8 +116,8 @@ blockchainTests.resets('Mixins tests', env => {
it('should revert with with a signature type that equals `NSignatureTypes`', async () => { it('should revert with with a signature type that equals `NSignatureTypes`', async () => {
const data = constants.NULL_BYTES; const data = constants.NULL_BYTES;
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
transaction.signature = hexConcat( transaction.signature = hexUtils.concat(
hexSlice(transaction.signature, 0, transaction.signature.length - 1), hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
SignatureType.NSignatureTypes, SignatureType.NSignatureTypes,
); );
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@ -134,8 +132,8 @@ blockchainTests.resets('Mixins tests', env => {
it("should revert with with a signature type that isn't supported", async () => { it("should revert with with a signature type that isn't supported", async () => {
const data = constants.NULL_BYTES; const data = constants.NULL_BYTES;
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
transaction.signature = hexConcat( transaction.signature = hexUtils.concat(
hexSlice(transaction.signature, 0, transaction.signature.length - 1), hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
SignatureType.Wallet, SignatureType.Wallet,
); );
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@ -296,10 +294,10 @@ blockchainTests.resets('Mixins tests', env => {
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress); const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
const signature = hexConcat( const signature = hexUtils.concat(
hexSlice(approval.signature, 0, 2), hexUtils.slice(approval.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval.signature, 6), hexUtils.slice(approval.signature, 6),
); );
const tx = mixins const tx = mixins
.assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [ .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@ -432,10 +430,10 @@ blockchainTests.resets('Mixins tests', env => {
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress); const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
const signature = hexConcat( const signature = hexUtils.concat(
hexSlice(approval.signature, 0, 2), hexUtils.slice(approval.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval.signature, 6), hexUtils.slice(approval.signature, 6),
); );
const tx = mixins const tx = mixins
.assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [ .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@ -454,10 +452,10 @@ blockchainTests.resets('Mixins tests', env => {
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress); const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress); const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
const approvalSignature2 = hexConcat( const approvalSignature2 = hexUtils.concat(
hexSlice(approval2.signature, 0, 2), hexUtils.slice(approval2.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval2.signature, 6), hexUtils.slice(approval2.signature, 6),
); );
const tx = mixins const tx = mixins
.assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [ .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@ -476,10 +474,10 @@ blockchainTests.resets('Mixins tests', env => {
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
const transaction = await transactionFactory.newSignedTransactionAsync({ data }); const transaction = await transactionFactory.newSignedTransactionAsync({ data });
const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress); const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
const approvalSignature2 = hexConcat( const approvalSignature2 = hexUtils.concat(
hexSlice(approval2.signature, 0, 2), hexUtils.slice(approval2.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval2.signature, 6), hexUtils.slice(approval2.signature, 6),
); );
const tx = mixins const tx = mixins
.assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [ .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [

19
contracts/erc20-bridge-sampler/test/erc20-bridge-sampler.ts
View File

@ -4,15 +4,10 @@ import {
expect, expect,
getRandomInteger, getRandomInteger,
getRandomPortion, getRandomPortion,
hexConcat,
hexHash,
hexLeftPad,
hexRandom,
randomAddress, randomAddress,
toHex,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { Order, OrderInfo } from '@0x/types'; import { Order, OrderInfo } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { artifacts } from './artifacts'; import { artifacts } from './artifacts';
@ -31,8 +26,8 @@ blockchainTests('erc20-bridge-sampler', env => {
const ETH2DAI_SALT = '0xb713b61bb9bb2958a0f5d1534b21e94fc68c4c0c034b0902ed844f2f6cd1b4f7'; const ETH2DAI_SALT = '0xb713b61bb9bb2958a0f5d1534b21e94fc68c4c0c034b0902ed844f2f6cd1b4f7';
const UNISWAP_BASE_SALT = '0x1d6a6a0506b0b4a554b907a4c29d9f4674e461989d9c1921feb17b26716385ab'; const UNISWAP_BASE_SALT = '0x1d6a6a0506b0b4a554b907a4c29d9f4674e461989d9c1921feb17b26716385ab';
const ERC20_PROXY_ID = '0xf47261b0'; const ERC20_PROXY_ID = '0xf47261b0';
const INVALID_ASSET_PROXY_ASSET_DATA = hexConcat('0xf47261b1', hexLeftPad(randomAddress())); const INVALID_ASSET_PROXY_ASSET_DATA = hexUtils.concat('0xf47261b1', hexUtils.leftPad(randomAddress()));
const INVALID_ASSET_DATA = hexRandom(37); const INVALID_ASSET_DATA = hexUtils.random(37);
const SELL_SOURCES = ['Eth2Dai', 'Kyber', 'Uniswap']; const SELL_SOURCES = ['Eth2Dai', 'Kyber', 'Uniswap'];
const BUY_SOURCES = ['Eth2Dai', 'Uniswap']; const BUY_SOURCES = ['Eth2Dai', 'Uniswap'];
const EMPTY_ORDERS_ERROR = 'EMPTY_ORDERS'; const EMPTY_ORDERS_ERROR = 'EMPTY_ORDERS';
@ -60,7 +55,7 @@ blockchainTests('erc20-bridge-sampler', env => {
}); });
function getPackedHash(...args: string[]): string { function getPackedHash(...args: string[]): string {
return hexHash(hexConcat(...args.map(a => toHex(a)))); return hexUtils.hash(hexUtils.concat(...args.map(a => hexUtils.toHex(a))));
} }
function getUniswapExchangeSalt(tokenAddress: string): string { function getUniswapExchangeSalt(tokenAddress: string): string {
@ -198,7 +193,7 @@ blockchainTests('erc20-bridge-sampler', env => {
} }
function getDeterministicOrderInfo(order: Order): OrderInfo { function getDeterministicOrderInfo(order: Order): OrderInfo {
const hash = getPackedHash(hexLeftPad(order.salt, 32)); const hash = getPackedHash(hexUtils.leftPad(order.salt, 32));
return { return {
orderHash: hash, orderHash: hash,
orderStatus: new BigNumber(hash).mod(255).toNumber(), orderStatus: new BigNumber(hash).mod(255).toNumber(),
@ -207,7 +202,7 @@ blockchainTests('erc20-bridge-sampler', env => {
} }
function getERC20AssetData(tokenAddress: string): string { function getERC20AssetData(tokenAddress: string): string {
return hexConcat(ERC20_PROXY_ID, hexLeftPad(tokenAddress)); return hexUtils.concat(ERC20_PROXY_ID, hexUtils.leftPad(tokenAddress));
} }
function getSampleAmounts(tokenAddress: string, count?: number): BigNumber[] { function getSampleAmounts(tokenAddress: string, count?: number): BigNumber[] {
@ -234,7 +229,7 @@ blockchainTests('erc20-bridge-sampler', env => {
takerAssetData: getERC20AssetData(takerToken), takerAssetData: getERC20AssetData(takerToken),
makerFeeAssetData: getERC20AssetData(randomAddress()), makerFeeAssetData: getERC20AssetData(randomAddress()),
takerFeeAssetData: getERC20AssetData(randomAddress()), takerFeeAssetData: getERC20AssetData(randomAddress()),
salt: new BigNumber(hexRandom()), salt: new BigNumber(hexUtils.random()),
expirationTimeSeconds: getRandomInteger(0, 2 ** 32), expirationTimeSeconds: getRandomInteger(0, 2 ** 32),
}; };
} }

21
contracts/erc20/test/lib_erc20_token.ts
View File

@ -3,11 +3,10 @@ import {
constants, constants,
expect, expect,
getRandomInteger, getRandomInteger,
hexLeftPad,
randomAddress, randomAddress,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { RawRevertError, StringRevertError } from '@0x/utils'; import { hexUtils, RawRevertError, StringRevertError } from '@0x/utils';
import { TestLibERC20TokenContract, TestLibERC20TokenTargetEvents } from './wrappers'; import { TestLibERC20TokenContract, TestLibERC20TokenTargetEvents } from './wrappers';
@ -17,11 +16,11 @@ blockchainTests('LibERC20Token', env => {
let testContract: TestLibERC20TokenContract; let testContract: TestLibERC20TokenContract;
const REVERT_STRING = 'WHOOPSIE'; const REVERT_STRING = 'WHOOPSIE';
const ENCODED_REVERT = new StringRevertError(REVERT_STRING).encode(); const ENCODED_REVERT = new StringRevertError(REVERT_STRING).encode();
const ENCODED_TRUE = hexLeftPad(1); const ENCODED_TRUE = hexUtils.leftPad(1);
const ENCODED_FALSE = hexLeftPad(0); const ENCODED_FALSE = hexUtils.leftPad(0);
const ENCODED_TWO = hexLeftPad(2); const ENCODED_TWO = hexUtils.leftPad(2);
const ENCODED_SHORT_TRUE = hexLeftPad(2, 31); const ENCODED_SHORT_TRUE = hexUtils.leftPad(2, 31);
const ENCODED_LONG_TRUE = hexLeftPad(2, 33); const ENCODED_LONG_TRUE = hexUtils.leftPad(2, 33);
before(async () => { before(async () => {
testContract = await TestLibERC20TokenContract.deployFrom0xArtifactAsync( testContract = await TestLibERC20TokenContract.deployFrom0xArtifactAsync(
@ -301,14 +300,14 @@ blockchainTests('LibERC20Token', env => {
describe('decimals()', () => { describe('decimals()', () => {
const DEFAULT_DECIMALS = 18; const DEFAULT_DECIMALS = 18;
const ENCODED_ZERO = hexLeftPad(0); const ENCODED_ZERO = hexUtils.leftPad(0);
const ENCODED_SHORT_ZERO = hexLeftPad(0, 31); const ENCODED_SHORT_ZERO = hexUtils.leftPad(0, 31);
const ENCODED_LONG_ZERO = hexLeftPad(0, 33); const ENCODED_LONG_ZERO = hexUtils.leftPad(0, 33);
const randomDecimals = () => Math.floor(Math.random() * 256) + 1; const randomDecimals = () => Math.floor(Math.random() * 256) + 1;
it('returns the number of decimals defined by the token', async () => { it('returns the number of decimals defined by the token', async () => {
const decimals = randomDecimals(); const decimals = randomDecimals();
const encodedDecimals = hexLeftPad(decimals); const encodedDecimals = hexUtils.leftPad(decimals);
const result = await testContract.testDecimals(false, ENCODED_REVERT, encodedDecimals).callAsync(); const result = await testContract.testDecimals(false, ENCODED_REVERT, encodedDecimals).callAsync();
return expect(result).to.bignumber.eq(decimals); return expect(result).to.bignumber.eq(decimals);
}); });

10
contracts/exchange-forwarder/test/asset_test.ts
View File

@ -16,12 +16,10 @@ import {
constants, constants,
expect, expect,
getRandomInteger, getRandomInteger,
hexRandom,
hexSlice,
randomAddress, randomAddress,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber, ExchangeForwarderRevertErrors } from '@0x/utils'; import { BigNumber, ExchangeForwarderRevertErrors, hexUtils } from '@0x/utils';
import { artifacts } from './artifacts'; import { artifacts } from './artifacts';
import { TestForwarderContract } from './wrappers'; import { TestForwarderContract } from './wrappers';
@ -76,7 +74,7 @@ blockchainTests('Supported asset type unit tests', env => {
erc721AssetData = assetDataEncoder.ERC721Token(erc721Token.address, nftId).getABIEncodedTransactionData(); erc721AssetData = assetDataEncoder.ERC721Token(erc721Token.address, nftId).getABIEncodedTransactionData();
bridgeAddress = randomAddress(); bridgeAddress = randomAddress();
bridgeData = hexRandom(); bridgeData = hexUtils.random();
erc20BridgeAssetData = assetDataEncoder erc20BridgeAssetData = assetDataEncoder
.ERC20Bridge(erc20Token.address, bridgeAddress, bridgeData) .ERC20Bridge(erc20Token.address, bridgeAddress, bridgeData)
.getABIEncodedTransactionData(); .getABIEncodedTransactionData();
@ -171,12 +169,12 @@ blockchainTests('Supported asset type unit tests', env => {
); );
}); });
it('reverts if assetData is unsupported', async () => { it('reverts if assetData is unsupported', async () => {
const randomBytes = hexRandom(); const randomBytes = hexUtils.random();
const tx = forwarder const tx = forwarder
.transferAssetToSender(randomBytes, TRANSFER_AMOUNT) .transferAssetToSender(randomBytes, TRANSFER_AMOUNT)
.awaitTransactionSuccessAsync({ from: receiver }); .awaitTransactionSuccessAsync({ from: receiver });
const expectedError = new ExchangeForwarderRevertErrors.UnsupportedAssetProxyError( const expectedError = new ExchangeForwarderRevertErrors.UnsupportedAssetProxyError(
hexSlice(randomBytes, 0, 4), hexUtils.slice(randomBytes, 0, 4),
); );
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });

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

@ -3,13 +3,12 @@ import {
constants, constants,
describe, describe,
expect, expect,
hexRandom,
testCombinatoriallyWithReferenceFunc, testCombinatoriallyWithReferenceFunc,
uint256Values, uint256Values,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { SafeMathRevertErrors } from '@0x/contracts-utils'; import { SafeMathRevertErrors } from '@0x/contracts-utils';
import { FillResults, MatchedFillResults, Order } from '@0x/types'; import { FillResults, MatchedFillResults, Order } from '@0x/types';
import { BigNumber, LibMathRevertErrors } from '@0x/utils'; import { BigNumber, hexUtils, LibMathRevertErrors } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper'; import { Web3Wrapper } from '@0x/web3-wrapper';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -46,9 +45,9 @@ blockchainTests('LibFillResults', env => {
exchangeAddress: constants.NULL_ADDRESS, exchangeAddress: constants.NULL_ADDRESS,
}; };
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const randomAssetData = () => hexRandom(36); const randomAssetData = () => hexUtils.random(36);
const randomUint256 = () => new BigNumber(hexRandom(constants.WORD_LENGTH)); const randomUint256 = () => new BigNumber(hexUtils.random(constants.WORD_LENGTH));
let libsContract: TestLibFillResultsContract; let libsContract: TestLibFillResultsContract;
let makerAddressLeft: string; let makerAddressLeft: string;

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

@ -1,7 +1,7 @@
import { blockchainTests, constants, describe, expect, hexRandom, orderHashUtils } from '@0x/contracts-test-utils'; import { blockchainTests, constants, describe, expect, orderHashUtils } from '@0x/contracts-test-utils';
import { eip712Utils } from '@0x/order-utils'; import { eip712Utils } from '@0x/order-utils';
import { Order } from '@0x/types'; import { Order } from '@0x/types';
import { BigNumber, signTypedDataUtils } from '@0x/utils'; import { BigNumber, hexUtils, signTypedDataUtils } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -12,10 +12,10 @@ import { artifacts } from './artifacts';
blockchainTests('LibOrder', env => { blockchainTests('LibOrder', env => {
let libOrderContract: TestLibOrderContract; let libOrderContract: TestLibOrderContract;
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const randomHash = () => hexRandom(constants.WORD_LENGTH); const randomHash = () => hexUtils.random(constants.WORD_LENGTH);
const randomUint256 = () => new BigNumber(randomHash()); const randomUint256 = () => new BigNumber(randomHash());
const randomAssetData = () => hexRandom(36); const randomAssetData = () => hexUtils.random(36);
const EMPTY_ORDER: Order = { const EMPTY_ORDER: Order = {
exchangeAddress: constants.NULL_ADDRESS, exchangeAddress: constants.NULL_ADDRESS,

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

@ -1,14 +1,7 @@
import { import { blockchainTests, constants, describe, expect, transactionHashUtils } from '@0x/contracts-test-utils';
blockchainTests,
constants,
describe,
expect,
hexRandom,
transactionHashUtils,
} from '@0x/contracts-test-utils';
import { eip712Utils } from '@0x/order-utils'; import { eip712Utils } from '@0x/order-utils';
import { ZeroExTransaction } from '@0x/types'; import { ZeroExTransaction } from '@0x/types';
import { BigNumber, signTypedDataUtils } from '@0x/utils'; import { BigNumber, hexUtils, signTypedDataUtils } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -19,10 +12,10 @@ import { artifacts } from './artifacts';
blockchainTests('LibZeroExTransaction', env => { blockchainTests('LibZeroExTransaction', env => {
let libZeroExTransactionContract: TestLibZeroExTransactionContract; let libZeroExTransactionContract: TestLibZeroExTransactionContract;
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const randomHash = () => hexRandom(constants.WORD_LENGTH); const randomHash = () => hexUtils.random(constants.WORD_LENGTH);
const randomUint256 = () => new BigNumber(randomHash()); const randomUint256 = () => new BigNumber(randomHash());
const randomAssetData = () => hexRandom(36); const randomAssetData = () => hexUtils.random(36);
const EMPTY_TRANSACTION: ZeroExTransaction = { const EMPTY_TRANSACTION: ZeroExTransaction = {
salt: constants.ZERO_AMOUNT, salt: constants.ZERO_AMOUNT,

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

@ -1,8 +1,8 @@
import { ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs'; import { ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs';
import { blockchainTests, constants, expect, hexRandom, orderHashUtils } from '@0x/contracts-test-utils'; import { blockchainTests, constants, expect, orderHashUtils } from '@0x/contracts-test-utils';
import { SafeMathRevertErrors } from '@0x/contracts-utils'; import { SafeMathRevertErrors } from '@0x/contracts-utils';
import { Order } from '@0x/types'; import { Order } from '@0x/types';
import { BigNumber, ExchangeRevertErrors } from '@0x/utils'; import { BigNumber, ExchangeRevertErrors, hexUtils } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper'; import { Web3Wrapper } from '@0x/web3-wrapper';
import { LogWithDecodedArgs } from 'ethereum-types'; import { LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -16,9 +16,9 @@ import {
blockchainTests('Exchange core internal functions', env => { blockchainTests('Exchange core internal functions', env => {
const CHAIN_ID = 1337; const CHAIN_ID = 1337;
const ONE_ETHER = constants.ONE_ETHER; const ONE_ETHER = constants.ONE_ETHER;
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const randomHash = () => hexRandom(constants.WORD_LENGTH); const randomHash = () => hexUtils.random(constants.WORD_LENGTH);
const randomAssetData = () => hexRandom(36); const randomAssetData = () => hexUtils.random(36);
let testExchange: TestExchangeInternalsContract; let testExchange: TestExchangeInternalsContract;
let senderAddress: string; let senderAddress: string;
const DEFAULT_PROTOCOL_MULTIPLIER = new BigNumber(150000); const DEFAULT_PROTOCOL_MULTIPLIER = new BigNumber(150000);

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

@ -1,8 +1,8 @@
import { LibMathRevertErrors, ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs'; import { LibMathRevertErrors, ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs';
import { blockchainTests, constants, expect, hexRandom } from '@0x/contracts-test-utils'; import { blockchainTests, constants, expect } from '@0x/contracts-test-utils';
import { SafeMathRevertErrors } from '@0x/contracts-utils'; import { SafeMathRevertErrors } from '@0x/contracts-utils';
import { FillResults, OrderInfo, OrderStatus, SignatureType } from '@0x/types'; import { FillResults, OrderInfo, OrderStatus, SignatureType } from '@0x/types';
import { BigNumber, ExchangeRevertErrors } from '@0x/utils'; import { BigNumber, ExchangeRevertErrors, hexUtils } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { import {
@ -16,7 +16,7 @@ import {
} from './utils/isolated_exchange_wrapper'; } from './utils/isolated_exchange_wrapper';
blockchainTests('Isolated fillOrder() tests', env => { blockchainTests('Isolated fillOrder() tests', env => {
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const getCurrentTime = () => Math.floor(_.now() / 1000); const getCurrentTime = () => Math.floor(_.now() / 1000);
const { ZERO_AMOUNT, ONE_ETHER, MAX_UINT256_ROOT } = constants; const { ZERO_AMOUNT, ONE_ETHER, MAX_UINT256_ROOT } = constants;
const ONE_DAY = 60 * 60 * 24; const ONE_DAY = 60 * 60 * 24;

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

@ -1,14 +1,6 @@
import { import { blockchainTests, constants, expect, OrderStatus, orderUtils, randomAddress } from '@0x/contracts-test-utils';
blockchainTests,
constants,
expect,
hexRandom,
OrderStatus,
orderUtils,
randomAddress,
} from '@0x/contracts-test-utils';
import { generatePseudoRandomSalt } from '@0x/order-utils'; import { generatePseudoRandomSalt } from '@0x/order-utils';
import { BigNumber, ExchangeRevertErrors, RevertError } from '@0x/utils'; import { BigNumber, ExchangeRevertErrors, hexUtils, RevertError } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { artifacts } from './artifacts'; import { artifacts } from './artifacts';
@ -63,9 +55,9 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
const orderHash = orderUtils.generatePseudoRandomOrderHash(); const orderHash = orderUtils.generatePseudoRandomOrderHash();
const signer = randomAddress(); const signer = randomAddress();
const validator = randomAddress(); const validator = randomAddress();
const data = hexRandom(ERROR_DATA_LENGTH); const data = hexUtils.random(ERROR_DATA_LENGTH);
const signature = hexRandom(SIGNATURE_LENGTH); const signature = hexUtils.random(SIGNATURE_LENGTH);
const errorData = hexRandom(ERROR_DATA_LENGTH); const errorData = hexUtils.random(ERROR_DATA_LENGTH);
createDecodeTest(ExchangeRevertErrors.SignatureError, [errorCode, orderHash, signer, signature]); createDecodeTest(ExchangeRevertErrors.SignatureError, [errorCode, orderHash, signer, signature]);
createDecodeTest(ExchangeRevertErrors.SignatureValidatorNotApprovedError, [signer, validator]); createDecodeTest(ExchangeRevertErrors.SignatureValidatorNotApprovedError, [signer, validator]);
createDecodeTest(ExchangeRevertErrors.EIP1271SignatureError, [validator, data, signature, errorData]); createDecodeTest(ExchangeRevertErrors.EIP1271SignatureError, [validator, data, signature, errorData]);
@ -114,7 +106,7 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
(() => { (() => {
const assetProxyAddress = randomAddress(); const assetProxyAddress = randomAddress();
createDecodeTest(ExchangeRevertErrors.AssetProxyExistsError, [ createDecodeTest(ExchangeRevertErrors.AssetProxyExistsError, [
hexRandom(ASSET_PROXY_ID_LENGTH), hexUtils.random(ASSET_PROXY_ID_LENGTH),
assetProxyAddress, assetProxyAddress,
]); ]);
})(); })();
@ -122,14 +114,14 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
(() => { (() => {
const errorCode = ExchangeRevertErrors.AssetProxyDispatchErrorCode.UnknownAssetProxy; const errorCode = ExchangeRevertErrors.AssetProxyDispatchErrorCode.UnknownAssetProxy;
const orderHash = orderUtils.generatePseudoRandomOrderHash(); const orderHash = orderUtils.generatePseudoRandomOrderHash();
const assetData = hexRandom(ASSET_DATA_LENGTH); const assetData = hexUtils.random(ASSET_DATA_LENGTH);
createDecodeTest(ExchangeRevertErrors.AssetProxyDispatchError, [errorCode, orderHash, assetData]); createDecodeTest(ExchangeRevertErrors.AssetProxyDispatchError, [errorCode, orderHash, assetData]);
})(); })();
(() => { (() => {
const orderHash = orderUtils.generatePseudoRandomOrderHash(); const orderHash = orderUtils.generatePseudoRandomOrderHash();
const assetData = hexRandom(ASSET_DATA_LENGTH); const assetData = hexUtils.random(ASSET_DATA_LENGTH);
const errorData = hexRandom(ERROR_DATA_LENGTH); const errorData = hexUtils.random(ERROR_DATA_LENGTH);
createDecodeTest(ExchangeRevertErrors.AssetProxyTransferError, [orderHash, assetData, errorData]); createDecodeTest(ExchangeRevertErrors.AssetProxyTransferError, [orderHash, assetData, errorData]);
})(); })();
@ -147,14 +139,14 @@ blockchainTests.resets('LibExchangeRichErrorDecoder', ({ provider, txDefaults })
(() => { (() => {
const transactionHash = orderUtils.generatePseudoRandomOrderHash(); const transactionHash = orderUtils.generatePseudoRandomOrderHash();
const errorData = hexRandom(ERROR_DATA_LENGTH); const errorData = hexUtils.random(ERROR_DATA_LENGTH);
createDecodeTest(ExchangeRevertErrors.TransactionExecutionError, [transactionHash, errorData]); createDecodeTest(ExchangeRevertErrors.TransactionExecutionError, [transactionHash, errorData]);
})(); })();
(() => { (() => {
const errorCode = ExchangeRevertErrors.IncompleteFillErrorCode.IncompleteMarketSellOrders; const errorCode = ExchangeRevertErrors.IncompleteFillErrorCode.IncompleteMarketSellOrders;
const expectedAmount = new BigNumber(hexRandom(WORD_LENGTH)); const expectedAmount = new BigNumber(hexUtils.random(WORD_LENGTH));
const actualAmount = new BigNumber(hexRandom(WORD_LENGTH)); const actualAmount = new BigNumber(hexUtils.random(WORD_LENGTH));
createDecodeTest(ExchangeRevertErrors.IncompleteFillError, [errorCode, expectedAmount, actualAmount]); createDecodeTest(ExchangeRevertErrors.IncompleteFillError, [errorCode, expectedAmount, actualAmount]);
})(); })();
}); });

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

@ -1,5 +1,5 @@
import { blockchainTests, constants, describe, expect, hexRandom } from '@0x/contracts-test-utils'; import { blockchainTests, constants, describe, expect } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { DataItem, MethodAbi, TupleDataItem } from 'ethereum-types'; import { DataItem, MethodAbi, TupleDataItem } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -47,11 +47,11 @@ blockchainTests.resets('Reentrancy Tests', env => {
} }
// Handle bytes. // Handle bytes.
if (item.type === 'bytes') { if (item.type === 'bytes') {
return hexRandom(36); return hexUtils.random(36);
} }
// Handle addresses. // Handle addresses.
if (item.type === 'address') { if (item.type === 'address') {
return hexRandom(constants.ADDRESS_LENGTH); return hexUtils.random(constants.ADDRESS_LENGTH);
} }
// Handle bools. // Handle bools.
if (item.type === 'bool') { if (item.type === 'bool') {
@ -84,7 +84,7 @@ blockchainTests.resets('Reentrancy Tests', env => {
m = /^bytes(\d+)$/.exec(item.type); m = /^bytes(\d+)$/.exec(item.type);
if (m) { if (m) {
const size = parseInt(m[1], 10) || 32; const size = parseInt(m[1], 10) || 32;
return hexRandom(size); return hexUtils.random(size);
} }
throw new Error(`Unhandled input type: ${item.type}`); throw new Error(`Unhandled input type: ${item.type}`);
} }

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

@ -5,8 +5,6 @@ import {
blockchainTests, blockchainTests,
constants, constants,
expect, expect,
hexConcat,
hexRandom,
LogDecoder, LogDecoder,
OrderFactory, OrderFactory,
orderHashUtils, orderHashUtils,
@ -16,7 +14,7 @@ import {
transactionHashUtils, transactionHashUtils,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { SignatureType, SignedOrder, SignedZeroExTransaction } from '@0x/types'; import { SignatureType, SignedOrder, SignedZeroExTransaction } from '@0x/types';
import { BigNumber, ExchangeRevertErrors, StringRevertError } from '@0x/utils'; import { BigNumber, ExchangeRevertErrors, hexUtils, StringRevertError } from '@0x/utils';
import { LogWithDecodedArgs } from 'ethereum-types'; import { LogWithDecodedArgs } from 'ethereum-types';
import ethUtil = require('ethereumjs-util'); import ethUtil = require('ethereumjs-util');
@ -89,11 +87,11 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
const SIGNATURE_LENGTH = 65; const SIGNATURE_LENGTH = 65;
const generateRandomSignature = (): string => hexRandom(SIGNATURE_LENGTH); const generateRandomSignature = (): string => hexUtils.random(SIGNATURE_LENGTH);
const hashBytes = (bytesHex: string): string => ethUtil.bufferToHex(ethUtil.sha3(ethUtil.toBuffer(bytesHex))); const hashBytes = (bytesHex: string): string => ethUtil.bufferToHex(ethUtil.sha3(ethUtil.toBuffer(bytesHex)));
const signDataHex = (dataHex: string, privateKey: Buffer): string => { const signDataHex = (dataHex: string, privateKey: Buffer): string => {
const ecSignature = ethUtil.ecsign(ethUtil.toBuffer(dataHex), privateKey); const ecSignature = ethUtil.ecsign(ethUtil.toBuffer(dataHex), privateKey);
return hexConcat(ecSignature.v, ecSignature.r, ecSignature.s); return hexUtils.concat(ecSignature.v, ecSignature.r, ecSignature.s);
}; };
type ValidateHashSignatureAsync = ( type ValidateHashSignatureAsync = (
@ -123,7 +121,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when signature type is unsupported', async () => { it('should revert when signature type is unsupported', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.NSignatureTypes); const signatureHex = hexUtils.concat(SignatureType.NSignatureTypes);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.Unsupported, ExchangeRevertErrors.SignatureErrorCode.Unsupported,
hashHex, hashHex,
@ -136,7 +134,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when SignatureType=Illegal', async () => { it('should revert when SignatureType=Illegal', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.Illegal); const signatureHex = hexUtils.concat(SignatureType.Illegal);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.Illegal, ExchangeRevertErrors.SignatureErrorCode.Illegal,
hashHex, hashHex,
@ -149,14 +147,14 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when SignatureType=Invalid and signature has a length of zero', async () => { it('should return false when SignatureType=Invalid and signature has a length of zero', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.Invalid); const signatureHex = hexUtils.concat(SignatureType.Invalid);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.false(); expect(isValidSignature).to.be.false();
}); });
it('should revert when SignatureType=Invalid and signature length is non-zero', async () => { it('should revert when SignatureType=Invalid and signature length is non-zero', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat('0xdeadbeef', SignatureType.Invalid); const signatureHex = hexUtils.concat('0xdeadbeef', SignatureType.Invalid);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidLength, ExchangeRevertErrors.SignatureErrorCode.InvalidLength,
hashHex, hashHex,
@ -169,14 +167,14 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return true when SignatureType=EIP712 and signature is valid', async () => { it('should return true when SignatureType=EIP712 and signature is valid', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(signDataHex(hashHex, signerPrivateKey), SignatureType.EIP712); const signatureHex = hexUtils.concat(signDataHex(hashHex, signerPrivateKey), SignatureType.EIP712);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.true(); expect(isValidSignature).to.be.true();
}); });
it('should return false when SignatureType=EIP712 and signature is invalid', async () => { it('should return false when SignatureType=EIP712 and signature is invalid', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.EIP712); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.EIP712);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.false(); expect(isValidSignature).to.be.false();
}); });
@ -187,7 +185,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
const orderHashWithEthSignPrefixHex = ethUtil.bufferToHex( const orderHashWithEthSignPrefixHex = ethUtil.bufferToHex(
ethUtil.hashPersonalMessage(ethUtil.toBuffer(hashHex)), ethUtil.hashPersonalMessage(ethUtil.toBuffer(hashHex)),
); );
const signatureHex = hexConcat( const signatureHex = hexUtils.concat(
signDataHex(orderHashWithEthSignPrefixHex, signerPrivateKey), signDataHex(orderHashWithEthSignPrefixHex, signerPrivateKey),
SignatureType.EthSign, SignatureType.EthSign,
); );
@ -198,7 +196,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when SignatureType=EthSign and signature is invalid', async () => { it('should return false when SignatureType=EthSign and signature is invalid', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
// Create EthSign signature // Create EthSign signature
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.EthSign); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.EthSign);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.false(); expect(isValidSignature).to.be.false();
}); });
@ -208,7 +206,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.Wallet);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
hashHex, hashHex,
validatorWallet.address, validatorWallet.address,
@ -225,7 +223,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const notSignatureDataHex = generateRandomSignature(); const notSignatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(notSignatureDataHex, SignatureType.Wallet); const signatureHex = hexUtils.concat(notSignatureDataHex, SignatureType.Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
hashHex, hashHex,
@ -241,7 +239,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
const hashHex = getCurrentHashHex(validatorWallet.address); const hashHex = getCurrentHashHex(validatorWallet.address);
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.Wallet); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.Wallet);
const expectedError = new ExchangeRevertErrors.SignatureWalletError( const expectedError = new ExchangeRevertErrors.SignatureWalletError(
hashHex, hashHex,
validatorWallet.address, validatorWallet.address,
@ -254,7 +252,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when signer is an EOA and SignatureType=Wallet', async () => { it('should revert when signer is an EOA and SignatureType=Wallet', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.Wallet); const signatureHex = hexUtils.concat(SignatureType.Wallet);
const expectedError = new ExchangeRevertErrors.SignatureWalletError( const expectedError = new ExchangeRevertErrors.SignatureWalletError(
hashHex, hashHex,
signerAddress, signerAddress,
@ -267,7 +265,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when validator returns `true` and SignatureType=Wallet', async () => { it('should return false when validator returns `true` and SignatureType=Wallet', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.Wallet); const signatureHex = hexUtils.concat(SignatureType.Wallet);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
hashHex, hashHex,
validatorWallet.address, validatorWallet.address,
@ -279,7 +277,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator returns nothing and SignatureType=Wallet', async () => { it('should revert when validator returns nothing and SignatureType=Wallet', async () => {
const hashHex = getCurrentHashHex(validatorWallet.address); const hashHex = getCurrentHashHex(validatorWallet.address);
const signatureHex = hexConcat(SignatureType.Wallet); const signatureHex = hexUtils.concat(SignatureType.Wallet);
const expectedError = new ExchangeRevertErrors.SignatureWalletError( const expectedError = new ExchangeRevertErrors.SignatureWalletError(
hashHex, hashHex,
validatorWallet.address, validatorWallet.address,
@ -299,7 +297,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
const hashHex = getCurrentHashHex(validatorWallet.address); const hashHex = getCurrentHashHex(validatorWallet.address);
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.Wallet); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.Wallet);
const expectedError = new ExchangeRevertErrors.SignatureWalletError( const expectedError = new ExchangeRevertErrors.SignatureWalletError(
hashHex, hashHex,
validatorWallet.address, validatorWallet.address,
@ -315,14 +313,14 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Presign the hash // Presign the hash
await exchange.preSign(hashHex).awaitTransactionSuccessAsync({ from: signerAddress }); await exchange.preSign(hashHex).awaitTransactionSuccessAsync({ from: signerAddress });
// Validate presigned signature // Validate presigned signature
const signatureHex = hexConcat(SignatureType.PreSigned); const signatureHex = hexUtils.concat(SignatureType.PreSigned);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.true(); expect(isValidSignature).to.be.true();
}); });
it('should return false when SignatureType=Presigned and signer has not presigned hash', async () => { it('should return false when SignatureType=Presigned and signer has not presigned hash', async () => {
const hashHex = getCurrentHashHex(); const hashHex = getCurrentHashHex();
const signatureHex = hexConcat(SignatureType.PreSigned); const signatureHex = hexUtils.concat(SignatureType.PreSigned);
const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex); const isValidSignature = await validateAsync(hashHex, signerAddress, signatureHex);
expect(isValidSignature).to.be.false(); expect(isValidSignature).to.be.false();
}); });
@ -355,7 +353,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}; };
it('should revert when signerAddress == 0', async () => { it('should revert when signerAddress == 0', async () => {
const signatureHex = hexConcat(SignatureType.EIP712); const signatureHex = hexUtils.concat(SignatureType.EIP712);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidSigner, ExchangeRevertErrors.SignatureErrorCode.InvalidSigner,
hashHex, hashHex,
@ -367,7 +365,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when SignatureType=Validator', async () => { it('should revert when SignatureType=Validator', async () => {
const signatureHex = hexConcat(SignatureType.Validator); const signatureHex = hexUtils.concat(SignatureType.Validator);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InappropriateSignatureType, ExchangeRevertErrors.SignatureErrorCode.InappropriateSignatureType,
hashHex, hashHex,
@ -379,7 +377,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when SignatureType=EIP1271Wallet', async () => { it('should revert when SignatureType=EIP1271Wallet', async () => {
const signatureHex = hexConcat(SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(SignatureType.EIP1271Wallet);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InappropriateSignatureType, ExchangeRevertErrors.SignatureErrorCode.InappropriateSignatureType,
hashHex, hashHex,
@ -466,7 +464,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}; };
it('should revert when signerAddress == 0', async () => { it('should revert when signerAddress == 0', async () => {
const signatureHex = hexConcat(SignatureType.EIP712); const signatureHex = hexUtils.concat(SignatureType.EIP712);
const nullMakerOrder = { const nullMakerOrder = {
...signedOrder, ...signedOrder,
makerAddress: constants.NULL_ADDRESS, makerAddress: constants.NULL_ADDRESS,
@ -486,7 +484,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
signatureHex, signatureHex,
@ -501,7 +499,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const notSignatureDataHex = generateRandomSignature(); const notSignatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(notSignatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(notSignatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
signatureHex, signatureHex,
@ -513,7 +511,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when validator returns `true` and SignatureType=Validator', async () => { it('should return false when validator returns `true` and SignatureType=Validator', async () => {
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
signatureHex, signatureHex,
@ -525,7 +523,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator returns nothing and SignatureType=Validator', async () => { it('should revert when validator returns nothing and SignatureType=Validator', async () => {
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -542,7 +540,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -559,7 +557,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -579,7 +577,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
.awaitTransactionSuccessAsync({ from: signedOrder.makerAddress }); .awaitTransactionSuccessAsync({ from: signedOrder.makerAddress });
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(SignatureType.Validator); const signatureHex = hexUtils.concat(SignatureType.Validator);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidLength, ExchangeRevertErrors.SignatureErrorCode.InvalidLength,
@ -599,7 +597,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const expectedError = new ExchangeRevertErrors.SignatureValidatorNotApprovedError( const expectedError = new ExchangeRevertErrors.SignatureValidatorNotApprovedError(
signedOrder.makerAddress, signedOrder.makerAddress,
validatorWallet.address, validatorWallet.address,
@ -613,7 +611,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
@ -630,7 +628,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const notSignatureDataHex = generateRandomSignature(); const notSignatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(notSignatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(notSignatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
@ -644,7 +642,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when validator returns `true` and SignatureType=EIP1271Wallet', async () => { it('should return false when validator returns `true` and SignatureType=EIP1271Wallet', async () => {
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedOrder, signedOrder,
@ -658,7 +656,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator returns nothing and SignatureType=EIP1271Wallet', async () => { it('should revert when validator returns nothing and SignatureType=EIP1271Wallet', async () => {
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -675,7 +673,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.EIP1271Wallet);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -690,7 +688,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator reverts and SignatureType=EIP1271Wallet', async () => { it('should revert when validator reverts and SignatureType=EIP1271Wallet', async () => {
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
const signatureHex = hexConcat(SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(SignatureType.EIP1271Wallet);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -704,7 +702,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when signer is an EOA and SignatureType=EIP1271Wallet', async () => { it('should revert when signer is an EOA and SignatureType=EIP1271Wallet', async () => {
const signatureHex = hexConcat(SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(SignatureType.EIP1271Wallet);
signedOrder.makerAddress = notSignerAddress; signedOrder.makerAddress = notSignerAddress;
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
@ -719,7 +717,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when signer is an EOA and SignatureType=Validator', async () => { it('should revert when signer is an EOA and SignatureType=Validator', async () => {
const signatureHex = hexConcat(notSignerAddress, SignatureType.Validator); const signatureHex = hexUtils.concat(notSignerAddress, SignatureType.Validator);
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData(); const data = eip1271Data.OrderWithHash(signedOrder, orderHashHex).getABIEncodedTransactionData();
const expectedError = new ExchangeRevertErrors.EIP1271SignatureError( const expectedError = new ExchangeRevertErrors.EIP1271SignatureError(
@ -766,7 +764,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// We don't actually do anything with the transaction so we can just // We don't actually do anything with the transaction so we can just
// fill it with random data. // fill it with random data.
signedTransaction = await transactionFactory.newSignedTransactionAsync({ signedTransaction = await transactionFactory.newSignedTransactionAsync({
data: hexRandom(TRANSACTION_DATA_LENGTH), data: hexUtils.random(TRANSACTION_DATA_LENGTH),
}); });
}); });
@ -790,7 +788,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}; };
it('should revert when signerAddress == 0', async () => { it('should revert when signerAddress == 0', async () => {
const signatureHex = hexConcat(SignatureType.EIP712); const signatureHex = hexUtils.concat(SignatureType.EIP712);
const nullSignerTransaction = { const nullSignerTransaction = {
...signedTransaction, ...signedTransaction,
signerAddress: constants.NULL_ADDRESS, signerAddress: constants.NULL_ADDRESS,
@ -810,7 +808,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
signatureHex, signatureHex,
@ -825,7 +823,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const notSignatureDataHex = generateRandomSignature(); const notSignatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(notSignatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(notSignatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
signatureHex, signatureHex,
@ -837,7 +835,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when validator returns `true` and SignatureType=Validator', async () => { it('should return false when validator returns `true` and SignatureType=Validator', async () => {
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
signatureHex, signatureHex,
@ -854,7 +852,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
.awaitTransactionSuccessAsync({ from: signedTransaction.signerAddress }); .awaitTransactionSuccessAsync({ from: signedTransaction.signerAddress });
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(SignatureType.Validator); const signatureHex = hexUtils.concat(SignatureType.Validator);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.InvalidLength, ExchangeRevertErrors.SignatureErrorCode.InvalidLength,
@ -868,7 +866,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator returns nothing and SignatureType=Validator', async () => { it('should revert when validator returns nothing and SignatureType=Validator', async () => {
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -892,7 +890,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -911,7 +909,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -934,7 +932,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(signatureDataHex, validatorWallet.address, SignatureType.Validator);
const expectedError = new ExchangeRevertErrors.SignatureValidatorNotApprovedError( const expectedError = new ExchangeRevertErrors.SignatureValidatorNotApprovedError(
signedTransaction.signerAddress, signedTransaction.signerAddress,
validatorWallet.address, validatorWallet.address,
@ -948,7 +946,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
@ -965,7 +963,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
// just does a hash comparison. // just does a hash comparison.
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const notSignatureDataHex = generateRandomSignature(); const notSignatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(notSignatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(notSignatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
@ -979,7 +977,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should return false when validator returns `true` and SignatureType=EIP1271Wallet', async () => { it('should return false when validator returns `true` and SignatureType=EIP1271Wallet', async () => {
signedTransaction.signerAddress = validatorWallet.address; signedTransaction.signerAddress = validatorWallet.address;
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
// Validate signature // Validate signature
const isValidSignature = await validateAsync( const isValidSignature = await validateAsync(
signedTransaction, signedTransaction,
@ -993,7 +991,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
it('should revert when validator returns nothing and SignatureType=EIP1271Wallet', async () => { it('should revert when validator returns nothing and SignatureType=EIP1271Wallet', async () => {
signedTransaction.signerAddress = validatorWallet.address; signedTransaction.signerAddress = validatorWallet.address;
const signatureDataHex = generateRandomSignature(); const signatureDataHex = generateRandomSignature();
const signatureHex = hexConcat(signatureDataHex, SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(signatureDataHex, SignatureType.EIP1271Wallet);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -1017,7 +1015,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
signedTransaction.signerAddress = validatorWallet.address; signedTransaction.signerAddress = validatorWallet.address;
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.EIP1271Wallet);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -1036,7 +1034,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
signedTransaction.signerAddress = validatorWallet.address; signedTransaction.signerAddress = validatorWallet.address;
// Doesn't have to contain a real signature since our wallet contract // Doesn't have to contain a real signature since our wallet contract
// just does a hash comparison. // just does a hash comparison.
const signatureHex = hexConcat(generateRandomSignature(), SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(generateRandomSignature(), SignatureType.EIP1271Wallet);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -1052,7 +1050,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when signer is an EOA and SignatureType=EIP1271Wallet', async () => { it('should revert when signer is an EOA and SignatureType=EIP1271Wallet', async () => {
const signatureHex = hexConcat(SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(SignatureType.EIP1271Wallet);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -1068,7 +1066,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert when signer is an EOA and SignatureType=Validator', async () => { it('should revert when signer is an EOA and SignatureType=Validator', async () => {
const signatureHex = hexConcat(notSignerAddress, SignatureType.Validator); const signatureHex = hexUtils.concat(notSignerAddress, SignatureType.Validator);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(signedTransaction);
const data = eip1271Data const data = eip1271Data
.ZeroExTransactionWithHash(signedTransaction, transactionHashHex) .ZeroExTransactionWithHash(signedTransaction, transactionHashHex)
@ -1206,7 +1204,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert if `Validator` signature type rejects during a second fill', async () => { it('should revert if `Validator` signature type rejects during a second fill', async () => {
const signatureHex = hexConcat(validatorWallet.address, SignatureType.Validator); const signatureHex = hexUtils.concat(validatorWallet.address, SignatureType.Validator);
signedOrder.signature = signatureHex; signedOrder.signature = signatureHex;
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
// Allow the signature check for the first fill. // Allow the signature check for the first fill.
@ -1234,7 +1232,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert if `Wallet` signature type rejects during a second fill', async () => { it('should revert if `Wallet` signature type rejects during a second fill', async () => {
const signatureHex = hexConcat(SignatureType.Wallet); const signatureHex = hexUtils.concat(SignatureType.Wallet);
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
signedOrder.signature = signatureHex; signedOrder.signature = signatureHex;
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
@ -1263,7 +1261,7 @@ blockchainTests.resets('MixinSignatureValidator', env => {
}); });
it('should revert if `EIP1271Wallet` signature type rejects during a second fill', async () => { it('should revert if `EIP1271Wallet` signature type rejects during a second fill', async () => {
const signatureHex = hexConcat(SignatureType.EIP1271Wallet); const signatureHex = hexUtils.concat(SignatureType.EIP1271Wallet);
signedOrder.makerAddress = validatorWallet.address; signedOrder.makerAddress = validatorWallet.address;
signedOrder.signature = signatureHex; signedOrder.signature = signatureHex;
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);

17
contracts/exchange/test/transactions_unit_tests.ts
View File

@ -1,13 +1,6 @@
import { import { blockchainTests, constants, describe, expect, transactionHashUtils } from '@0x/contracts-test-utils';
blockchainTests,
constants,
describe,
expect,
hexRandom,
transactionHashUtils,
} from '@0x/contracts-test-utils';
import { EIP712DomainWithDefaultSchema, ZeroExTransaction } from '@0x/types'; import { EIP712DomainWithDefaultSchema, ZeroExTransaction } from '@0x/types';
import { BigNumber, ExchangeRevertErrors, StringRevertError } from '@0x/utils'; import { BigNumber, ExchangeRevertErrors, hexUtils, StringRevertError } from '@0x/utils';
import { LogWithDecodedArgs } from 'ethereum-types'; import { LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -19,7 +12,7 @@ blockchainTests.resets('Transaction Unit Tests', ({ provider, web3Wrapper, txDef
let accounts: string[]; let accounts: string[];
let domain: EIP712DomainWithDefaultSchema; let domain: EIP712DomainWithDefaultSchema;
const randomSignature = () => hexRandom(66); const randomSignature = () => hexUtils.random(66);
const EMPTY_ZERO_EX_TRANSACTION = { const EMPTY_ZERO_EX_TRANSACTION = {
salt: constants.ZERO_AMOUNT, salt: constants.ZERO_AMOUNT,
@ -668,7 +661,7 @@ blockchainTests.resets('Transaction Unit Tests', ({ provider, web3Wrapper, txDef
describe('setCurrentContextAddressIfRequired', () => { describe('setCurrentContextAddressIfRequired', () => {
it('should set the currentContextAddress if signer not equal to sender', async () => { it('should set the currentContextAddress if signer not equal to sender', async () => {
const randomAddress = hexRandom(20); const randomAddress = hexUtils.random(20);
await transactionsContract await transactionsContract
.setCurrentContextAddressIfRequired(randomAddress, randomAddress) .setCurrentContextAddressIfRequired(randomAddress, randomAddress)
.awaitTransactionSuccessAsync(); .awaitTransactionSuccessAsync();
@ -676,7 +669,7 @@ blockchainTests.resets('Transaction Unit Tests', ({ provider, web3Wrapper, txDef
expect(currentContextAddress).to.eq(randomAddress); expect(currentContextAddress).to.eq(randomAddress);
}); });
it('should not set the currentContextAddress if signer equal to sender', async () => { it('should not set the currentContextAddress if signer equal to sender', async () => {
const randomAddress = hexRandom(20); const randomAddress = hexUtils.random(20);
await transactionsContract await transactionsContract
.setCurrentContextAddressIfRequired(accounts[0], randomAddress) .setCurrentContextAddressIfRequired(accounts[0], randomAddress)
.awaitTransactionSuccessAsync({ .awaitTransactionSuccessAsync({

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

@ -6,12 +6,11 @@ import {
describe, describe,
expect, expect,
getRandomPortion, getRandomPortion,
hexRandom,
orderHashUtils, orderHashUtils,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { ReferenceFunctions as UtilReferenceFunctions, SafeMathRevertErrors } from '@0x/contracts-utils'; import { ReferenceFunctions as UtilReferenceFunctions, SafeMathRevertErrors } from '@0x/contracts-utils';
import { FillResults, Order } from '@0x/types'; import { FillResults, Order } from '@0x/types';
import { AnyRevertError, BigNumber, ExchangeRevertErrors, StringRevertError } from '@0x/utils'; import { AnyRevertError, BigNumber, ExchangeRevertErrors, hexUtils, StringRevertError } from '@0x/utils';
import { LogEntry, LogWithDecodedArgs } from 'ethereum-types'; import { LogEntry, LogWithDecodedArgs } from 'ethereum-types';
import * as ethjs from 'ethereumjs-util'; import * as ethjs from 'ethereumjs-util';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -30,11 +29,11 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
const { addFillResults, getPartialAmountCeil } = LibReferenceFunctions; const { addFillResults, getPartialAmountCeil } = LibReferenceFunctions;
const { safeSub } = UtilReferenceFunctions; const { safeSub } = UtilReferenceFunctions;
const protocolFeeMultiplier = new BigNumber(150000); const protocolFeeMultiplier = new BigNumber(150000);
const randomAddress = () => hexRandom(constants.ADDRESS_LENGTH); const randomAddress = () => hexUtils.random(constants.ADDRESS_LENGTH);
const randomAssetData = () => hexRandom(34); const randomAssetData = () => hexUtils.random(34);
const randomAmount = (maxAmount: BigNumber = ONE_ETHER) => maxAmount.times(_.random(0, 100, true).toFixed(12)); const randomAmount = (maxAmount: BigNumber = ONE_ETHER) => maxAmount.times(_.random(0, 100, true).toFixed(12));
const randomTimestamp = () => new BigNumber(Math.floor(_.now() / 1000) + _.random(0, 34560)); const randomTimestamp = () => new BigNumber(Math.floor(_.now() / 1000) + _.random(0, 34560));
const randomSalt = () => new BigNumber(hexRandom(constants.WORD_LENGTH).substr(2), 16); const randomSalt = () => new BigNumber(hexUtils.random(constants.WORD_LENGTH).substr(2), 16);
const ALWAYS_FAILING_SALT = constants.MAX_UINT256; const ALWAYS_FAILING_SALT = constants.MAX_UINT256;
const ALWAYS_FAILING_SALT_REVERT_ERROR = new StringRevertError('ALWAYS_FAILING_SALT'); const ALWAYS_FAILING_SALT_REVERT_ERROR = new StringRevertError('ALWAYS_FAILING_SALT');
const EMPTY_FILL_RESULTS = { const EMPTY_FILL_RESULTS = {
@ -1090,7 +1089,7 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
takerAssetAmount: new BigNumber(20000), takerAssetAmount: new BigNumber(20000),
}), }),
]; ];
const signatures = [hexRandom()]; const signatures = [hexUtils.random()];
const fillAmount = new BigNumber(10000); const fillAmount = new BigNumber(10000);
const fillResults = await roundingTestContract const fillResults = await roundingTestContract
.marketBuyOrdersNoThrow(orders, fillAmount, signatures) .marketBuyOrdersNoThrow(orders, fillAmount, signatures)
@ -1105,7 +1104,7 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
takerAssetAmount: new BigNumber('6300000000000000000'), takerAssetAmount: new BigNumber('6300000000000000000'),
}), }),
]; ];
const signatures = [hexRandom()]; const signatures = [hexUtils.random()];
const fillAmount = new BigNumber('2400000000000000000'); const fillAmount = new BigNumber('2400000000000000000');
const fillResults = await roundingTestContract const fillResults = await roundingTestContract
.marketBuyOrdersNoThrow(orders, fillAmount, signatures) .marketBuyOrdersNoThrow(orders, fillAmount, signatures)
@ -1120,7 +1119,7 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
takerAssetAmount: new BigNumber('103048102885858024121'), takerAssetAmount: new BigNumber('103048102885858024121'),
}), }),
]; ];
const signatures = [hexRandom()]; const signatures = [hexUtils.random()];
const fillAmount = new BigNumber('84819838457312347759'); const fillAmount = new BigNumber('84819838457312347759');
const fillResults = await roundingTestContract const fillResults = await roundingTestContract
.marketBuyOrdersNoThrow(orders, fillAmount, signatures) .marketBuyOrdersNoThrow(orders, fillAmount, signatures)
@ -1134,7 +1133,7 @@ blockchainTests('Exchange wrapper functions unit tests.', env => {
it(`${i + 1}/${FUZZ_COUNT}`, async () => { it(`${i + 1}/${FUZZ_COUNT}`, async () => {
const ordersCount = _.random(1, 10); const ordersCount = _.random(1, 10);
const orders = _.times(ordersCount, () => randomOrder()); const orders = _.times(ordersCount, () => randomOrder());
const signatures = orders.map(() => hexRandom()); const signatures = orders.map(() => hexUtils.random());
const totalMakerAssetAmount = BigNumber.sum(...orders.map(o => o.makerAssetAmount)); const totalMakerAssetAmount = BigNumber.sum(...orders.map(o => o.makerAssetAmount));
const fillAmount = getRandomPortion(totalMakerAssetAmount); const fillAmount = getRandomPortion(totalMakerAssetAmount);
const fillResults = await roundingTestContract const fillResults = await roundingTestContract

9
contracts/extensions/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "5.1.0",
"changes": [
{
"note": "Export function `encodeDutchAuctionAssetData`",
"pr": 2373
}
]
},
{ {
"version": "5.0.0", "version": "5.0.0",
"changes": [ "changes": [

2
contracts/extensions/package.json
View File

@ -77,6 +77,8 @@
"chai-as-promised": "^7.1.0", "chai-as-promised": "^7.1.0",
"chai-bignumber": "^3.0.0", "chai-bignumber": "^3.0.0",
"dirty-chai": "^2.0.1", "dirty-chai": "^2.0.1",
"ethereumjs-abi": "0.6.5",
"ethereumjs-util": "^5.1.1",
"lodash": "^4.17.11", "lodash": "^4.17.11",
"make-promises-safe": "^1.1.0", "make-promises-safe": "^1.1.0",
"mocha": "^6.2.0", "mocha": "^6.2.0",

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

@ -15,7 +15,7 @@ import {
web3Wrapper, web3Wrapper,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils'; import { BlockchainLifecycle } from '@0x/dev-utils';
import { assetDataUtils, generatePseudoRandomSalt } from '@0x/order-utils'; import { generatePseudoRandomSalt } from '@0x/order-utils';
import { RevertReason, SignedOrder } from '@0x/types'; import { RevertReason, SignedOrder } from '@0x/types';
import { BigNumber, providerUtils } from '@0x/utils'; import { BigNumber, providerUtils } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper'; import { Web3Wrapper } from '@0x/web3-wrapper';
@ -26,6 +26,8 @@ import { DutchAuctionContract, DutchAuctionTestWrapper, WETH9Contract } from './
import { artifacts } from './artifacts'; import { artifacts } from './artifacts';
import { encodeDutchAuctionAssetData } from './utils';
chaiSetup.configure(); chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@ -158,7 +160,7 @@ describe(ContractName.DutchAuction, () => {
feeRecipientAddress, feeRecipientAddress,
// taker address or sender address should be set to the ducth auction contract // taker address or sender address should be set to the ducth auction contract
takerAddress: dutchAuctionContract.address, takerAddress: dutchAuctionContract.address,
makerAssetData: assetDataUtils.encodeDutchAuctionAssetData( makerAssetData: encodeDutchAuctionAssetData(
await devUtils.encodeERC20AssetData(defaultMakerAssetAddress).callAsync(), await devUtils.encodeERC20AssetData(defaultMakerAssetAddress).callAsync(),
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,
@ -202,7 +204,7 @@ describe(ContractName.DutchAuction, () => {
describe('matchOrders', () => { describe('matchOrders', () => {
it('should be worth the begin price at the begining of the auction', async () => { it('should be worth the begin price at the begining of the auction', async () => {
auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp + 2); auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp + 2);
const makerAssetData = assetDataUtils.encodeDutchAuctionAssetData( const makerAssetData = encodeDutchAuctionAssetData(
defaultERC20MakerAssetData, defaultERC20MakerAssetData,
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,
@ -216,7 +218,7 @@ describe(ContractName.DutchAuction, () => {
it('should be be worth the end price at the end of the auction', async () => { it('should be be worth the end price at the end of the auction', async () => {
auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds * 2); auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds * 2);
auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds); auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds);
const makerAssetData = assetDataUtils.encodeDutchAuctionAssetData( const makerAssetData = encodeDutchAuctionAssetData(
defaultERC20MakerAssetData, defaultERC20MakerAssetData,
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,
@ -282,7 +284,7 @@ describe(ContractName.DutchAuction, () => {
it('should revert when auction expires', async () => { it('should revert when auction expires', async () => {
auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds * 2); auctionBeginTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds * 2);
auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds); auctionEndTimeSeconds = new BigNumber(currentBlockTimestamp - tenMinutesInSeconds);
const makerAssetData = assetDataUtils.encodeDutchAuctionAssetData( const makerAssetData = encodeDutchAuctionAssetData(
defaultERC20MakerAssetData, defaultERC20MakerAssetData,
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,
@ -310,7 +312,7 @@ describe(ContractName.DutchAuction, () => {
}); });
it('begin time is less than end time', async () => { it('begin time is less than end time', async () => {
auctionBeginTimeSeconds = new BigNumber(auctionEndTimeSeconds).plus(tenMinutesInSeconds); auctionBeginTimeSeconds = new BigNumber(auctionEndTimeSeconds).plus(tenMinutesInSeconds);
const makerAssetData = assetDataUtils.encodeDutchAuctionAssetData( const makerAssetData = encodeDutchAuctionAssetData(
defaultERC20MakerAssetData, defaultERC20MakerAssetData,
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,
@ -336,7 +338,7 @@ describe(ContractName.DutchAuction, () => {
const erc721MakerAssetData = await devUtils const erc721MakerAssetData = await devUtils
.encodeERC721AssetData(erc721Token.address, makerAssetId) .encodeERC721AssetData(erc721Token.address, makerAssetId)
.callAsync(); .callAsync();
const makerAssetData = assetDataUtils.encodeDutchAuctionAssetData( const makerAssetData = encodeDutchAuctionAssetData(
erc721MakerAssetData, erc721MakerAssetData,
auctionBeginTimeSeconds, auctionBeginTimeSeconds,
auctionBeginAmount, auctionBeginAmount,

21
contracts/extensions/test/utils/index.ts
View File

@ -1,2 +1,23 @@
import { BigNumber } from '@0x/utils';
import * as ethAbi from 'ethereumjs-abi';
import * as ethUtil from 'ethereumjs-util';
export * from './balance_threshold_wrapper'; export * from './balance_threshold_wrapper';
export * from './dutch_auction_test_wrapper'; export * from './dutch_auction_test_wrapper';
// tslint:disable-next-line:completed-docs
export function encodeDutchAuctionAssetData(
assetData: string,
beginTimeSeconds: BigNumber,
beginAmount: BigNumber,
): string {
const assetDataBuffer = ethUtil.toBuffer(assetData);
const abiEncodedAuctionData = (ethAbi as any).rawEncode(
['uint256', 'uint256'],
[beginTimeSeconds.toString(), beginAmount.toString()],
);
const abiEncodedAuctionDataBuffer = ethUtil.toBuffer(abiEncodedAuctionData);
const dutchAuctionDataBuffer = Buffer.concat([assetDataBuffer, abiEncodedAuctionDataBuffer]);
const dutchAuctionData = ethUtil.bufferToHex(dutchAuctionDataBuffer);
return dutchAuctionData;
}

2
contracts/integrations/package.json
View File

@ -58,7 +58,7 @@
"@0x/contracts-exchange-libs": "^4.0.0", "@0x/contracts-exchange-libs": "^4.0.0",
"@0x/contracts-gen": "^2.0.0", "@0x/contracts-gen": "^2.0.0",
"@0x/contracts-utils": "^4.0.0", "@0x/contracts-utils": "^4.0.0",
"@0x/coordinator-server": "^1.0.3", "@0x/coordinator-server": "^1.0.4",
"@0x/dev-utils": "^3.0.0", "@0x/dev-utils": "^3.0.0",
"@0x/migrations": "^5.0.0", "@0x/migrations": "^5.0.0",
"@0x/order-utils": "^9.0.0", "@0x/order-utils": "^9.0.0",

16
contracts/integrations/test/coordinator/coordinator_test.ts
View File

@ -11,14 +11,12 @@ import {
constants, constants,
ExchangeFunctionName, ExchangeFunctionName,
expect, expect,
hexConcat,
hexSlice,
orderHashUtils, orderHashUtils,
transactionHashUtils, transactionHashUtils,
verifyEvents, verifyEvents,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { SignedOrder, SignedZeroExTransaction } from '@0x/types'; import { SignedOrder, SignedZeroExTransaction } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { Actor } from '../framework/actors/base'; import { Actor } from '../framework/actors/base';
import { FeeRecipient } from '../framework/actors/fee_recipient'; import { FeeRecipient } from '../framework/actors/fee_recipient';
@ -225,10 +223,10 @@ blockchainTests.resets('Coordinator integration tests', env => {
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
it(`${fnName} should revert with an invalid approval signature`, async () => { it(`${fnName} should revert with an invalid approval signature`, async () => {
const approvalSignature = hexConcat( const approvalSignature = hexUtils.concat(
hexSlice(approval.signature, 0, 2), hexUtils.slice(approval.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval.signature, 6), hexUtils.slice(approval.signature, 6),
); );
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
const tx = coordinator const tx = coordinator
@ -305,10 +303,10 @@ blockchainTests.resets('Coordinator integration tests', env => {
verifyEvents(txReceipt, orders.map(order => expectedFillEvent(order)), ExchangeEvents.Fill); verifyEvents(txReceipt, orders.map(order => expectedFillEvent(order)), ExchangeEvents.Fill);
}); });
it(`${fnName} should revert with an invalid approval signature`, async () => { it(`${fnName} should revert with an invalid approval signature`, async () => {
const approvalSignature = hexConcat( const approvalSignature = hexUtils.concat(
hexSlice(approval.signature, 0, 2), hexUtils.slice(approval.signature, 0, 2),
'0xFFFFFFFF', '0xFFFFFFFF',
hexSlice(approval.signature, 6), hexUtils.slice(approval.signature, 6),
); );
const transactionHash = transactionHashUtils.getTransactionHashHex(transaction); const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
const tx = coordinator const tx = coordinator

6
contracts/integrations/test/exchange/transaction_test.ts
View File

@ -18,15 +18,13 @@ import {
ExchangeFunctionName, ExchangeFunctionName,
expect, expect,
getLatestBlockTimestampAsync, getLatestBlockTimestampAsync,
hexConcat,
hexRandom,
orderHashUtils, orderHashUtils,
randomAddress, randomAddress,
transactionHashUtils, transactionHashUtils,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { FillResults, OrderStatus, SignatureType, SignedOrder } from '@0x/types'; import { FillResults, OrderStatus, SignatureType, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { LogWithDecodedArgs } from 'ethereum-types'; import { LogWithDecodedArgs } from 'ethereum-types';
import { Actor } from '../framework/actors/base'; import { Actor } from '../framework/actors/base';
@ -190,7 +188,7 @@ blockchainTests.resets('Transaction integration tests', env => {
const order = await maker.signOrderAsync(); const order = await maker.signOrderAsync();
const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, [order]); const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, [order]);
const transaction = await takers[0].signTransactionAsync({ data }); const transaction = await takers[0].signTransactionAsync({ data });
transaction.signature = hexConcat(hexRandom(65), SignatureType.EthSign); transaction.signature = hexUtils.concat(hexUtils.random(65), SignatureType.EthSign);
const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction); const transactionHashHex = transactionHashUtils.getTransactionHashHex(transaction);
const expectedError = new ExchangeRevertErrors.SignatureError( const expectedError = new ExchangeRevertErrors.SignatureError(
ExchangeRevertErrors.SignatureErrorCode.BadTransactionSignature, ExchangeRevertErrors.SignatureErrorCode.BadTransactionSignature,

12
contracts/integrations/test/forwarder/bridge_test.ts
View File

@ -1,16 +1,10 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy'; import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { DummyERC721TokenContract } from '@0x/contracts-erc721'; import { DummyERC721TokenContract } from '@0x/contracts-erc721';
import { ForwarderContract } from '@0x/contracts-exchange-forwarder'; import { ForwarderContract } from '@0x/contracts-exchange-forwarder';
import { import { blockchainTests, constants, getLatestBlockTimestampAsync, toBaseUnitAmount } from '@0x/contracts-test-utils';
blockchainTests,
constants,
getLatestBlockTimestampAsync,
hexConcat,
toBaseUnitAmount,
} from '@0x/contracts-test-utils';
import { generatePseudoRandomSalt } from '@0x/order-utils'; import { generatePseudoRandomSalt } from '@0x/order-utils';
import { SignatureType, SignedOrder } from '@0x/types'; import { SignatureType, SignedOrder } from '@0x/types';
import { AbiEncoder, BigNumber, ExchangeForwarderRevertErrors } from '@0x/utils'; import { AbiEncoder, BigNumber, ExchangeForwarderRevertErrors, hexUtils } from '@0x/utils';
import { deployEth2DaiBridgeAsync } from '../bridges/deploy_eth2dai_bridge'; import { deployEth2DaiBridgeAsync } from '../bridges/deploy_eth2dai_bridge';
import { deployUniswapBridgeAsync } from '../bridges/deploy_uniswap_bridge'; import { deployUniswapBridgeAsync } from '../bridges/deploy_uniswap_bridge';
@ -111,7 +105,7 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
takerFeeAssetData: wethAssetData, takerFeeAssetData: wethAssetData,
expirationTimeSeconds: new BigNumber(currentBlockTimestamp).plus(fifteenMinutesInSeconds), expirationTimeSeconds: new BigNumber(currentBlockTimestamp).plus(fifteenMinutesInSeconds),
salt: generatePseudoRandomSalt(), salt: generatePseudoRandomSalt(),
signature: hexConcat(SignatureType.Wallet), signature: hexUtils.concat(SignatureType.Wallet),
}; };
eth2DaiBridgeOrder = { eth2DaiBridgeOrder = {
...orderDefaults, ...orderDefaults,

16
contracts/integrations/test/forwarder/forwarder_test_factory.ts
View File

@ -1,16 +1,8 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy'; import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { ForwarderContract } from '@0x/contracts-exchange-forwarder'; import { ForwarderContract } from '@0x/contracts-exchange-forwarder';
import { import { constants, expect, getPercentageOfValue, Numberish, OrderStatus, provider } from '@0x/contracts-test-utils';
constants,
expect,
getPercentageOfValue,
hexSlice,
Numberish,
OrderStatus,
provider,
} from '@0x/contracts-test-utils';
import { AssetProxyId, OrderInfo, SignedOrder } from '@0x/types'; import { AssetProxyId, OrderInfo, SignedOrder } from '@0x/types';
import { BigNumber, RevertError } from '@0x/utils'; import { BigNumber, hexUtils, RevertError } from '@0x/utils';
import { TransactionReceiptWithDecodedLogs } from 'ethereum-types'; import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
import { FeeRecipient } from '../framework/actors/fee_recipient'; import { FeeRecipient } from '../framework/actors/fee_recipient';
@ -37,8 +29,8 @@ interface MarketBuyOptions extends MarketSellOptions {
} }
function areUnderlyingAssetsEqual(assetData1: string, assetData2: string): boolean { function areUnderlyingAssetsEqual(assetData1: string, assetData2: string): boolean {
const assetProxyId1 = hexSlice(assetData1, 0, 4); const assetProxyId1 = hexUtils.slice(assetData1, 0, 4);
const assetProxyId2 = hexSlice(assetData2, 0, 4); const assetProxyId2 = hexUtils.slice(assetData2, 0, 4);
if ( if (
(assetProxyId1 === AssetProxyId.ERC20 || assetProxyId1 === AssetProxyId.ERC20Bridge) && (assetProxyId1 === AssetProxyId.ERC20 || assetProxyId1 === AssetProxyId.ERC20Bridge) &&
(assetProxyId2 === AssetProxyId.ERC20 || assetProxyId2 === AssetProxyId.ERC20Bridge) (assetProxyId2 === AssetProxyId.ERC20 || assetProxyId2 === AssetProxyId.ERC20Bridge)

6
contracts/integrations/test/framework/balances/local_balance_store.ts
View File

@ -1,8 +1,8 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy'; import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { ReferenceFunctions } from '@0x/contracts-exchange-libs'; import { ReferenceFunctions } from '@0x/contracts-exchange-libs';
import { constants, hexSlice, Numberish, provider } from '@0x/contracts-test-utils'; import { constants, Numberish, provider } from '@0x/contracts-test-utils';
import { AssetProxyId, SignedOrder } from '@0x/types'; import { AssetProxyId, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { TransactionReceiptWithDecodedLogs } from 'ethereum-types'; import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -82,7 +82,7 @@ export class LocalBalanceStore extends BalanceStore {
if (fromAddress === toAddress || amount.isZero()) { if (fromAddress === toAddress || amount.isZero()) {
return; return;
} }
const assetProxyId = hexSlice(assetData, 0, 4); const assetProxyId = hexUtils.slice(assetData, 0, 4);
switch (assetProxyId) { switch (assetProxyId) {
case AssetProxyId.ERC20: { case AssetProxyId.ERC20: {
const tokenAddress = this._assetDataDecoder.getABIDecodedTransactionData<string>( const tokenAddress = this._assetDataDecoder.getABIDecodedTransactionData<string>(

6
contracts/multisig/test/utils/zero_ex_governor_wrapper.ts
View File

@ -1,5 +1,5 @@
import { constants, hexRandom, increaseTimeAndMineBlockAsync } from '@0x/contracts-test-utils'; import { constants, increaseTimeAndMineBlockAsync } from '@0x/contracts-test-utils';
import { AbiEncoder, BigNumber } from '@0x/utils'; import { AbiEncoder, BigNumber, hexUtils } from '@0x/utils';
import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs } from 'ethereum-types'; import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -22,7 +22,7 @@ export class ZeroExGovernorWrapper {
const batchTransactionData = batchTransactionEncoder.encode([data, destinations, values]); const batchTransactionData = batchTransactionEncoder.encode([data, destinations, values]);
const txReceipt = await this._governor const txReceipt = await this._governor
.submitTransaction( .submitTransaction(
hexRandom(20), // submitTransaction will fail if this is a null address hexUtils.random(20), // submitTransaction will fail if this is a null address
constants.ZERO_AMOUNT, constants.ZERO_AMOUNT,
batchTransactionData, batchTransactionData,
) )

40
contracts/multisig/test/zero_ex_governor.ts
View File

@ -1,7 +1,7 @@
import { blockchainTests, constants, expect, getLatestBlockTimestampAsync, hexRandom } from '@0x/contracts-test-utils'; import { blockchainTests, constants, expect, getLatestBlockTimestampAsync } from '@0x/contracts-test-utils';
import { LibBytesRevertErrors } from '@0x/contracts-utils'; import { LibBytesRevertErrors } from '@0x/contracts-utils';
import { RevertReason } from '@0x/types'; import { RevertReason } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { LogEntry, LogWithDecodedArgs } from 'ethereum-types'; import { LogEntry, LogWithDecodedArgs } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -71,8 +71,8 @@ blockchainTests.resets('ZeroExGovernor', env => {
functionCallTimeLockSecondsLength === undefined functionCallTimeLockSecondsLength === undefined
? functionSelectorLength ? functionSelectorLength
: functionCallTimeLockSecondsLength; : functionCallTimeLockSecondsLength;
const functionSelectors = _.times(functionSelectorLength, () => hexRandom(4)); const functionSelectors = _.times(functionSelectorLength, () => hexUtils.random(4));
const destinations = _.times(_destinationsLength, () => hexRandom(20)); const destinations = _.times(_destinationsLength, () => hexUtils.random(20));
const functionCallTimeLockSeconds = _.times(_functionCallTimeLockSecondsLength, () => const functionCallTimeLockSeconds = _.times(_functionCallTimeLockSecondsLength, () =>
BigNumber.random() // random int > 0 and < 1000 BigNumber.random() // random int > 0 and < 1000
.times(10000000) .times(10000000)
@ -395,7 +395,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(executionLog.args.transactionId).to.bignumber.eq(txId); expect(executionLog.args.transactionId).to.bignumber.eq(txId);
} }
it('should revert if the transaction is not confirmed by the required amount of signers', async () => { it('should revert if the transaction is not confirmed by the required amount of signers', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const results = await governorWrapper.submitTransactionAsync(data, destinations, signerAddresses[0]); const results = await governorWrapper.submitTransactionAsync(data, destinations, signerAddresses[0]);
const tx = governor.executeTransaction(results.txId).awaitTransactionSuccessAsync({ const tx = governor.executeTransaction(results.txId).awaitTransactionSuccessAsync({
@ -404,7 +404,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(tx).to.revertWith(RevertReason.TxNotFullyConfirmed); expect(tx).to.revertWith(RevertReason.TxNotFullyConfirmed);
}); });
it('should revert if the transaction is not confirmed by the required amount of signers and called by the submitter', async () => { it('should revert if the transaction is not confirmed by the required amount of signers and called by the submitter', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const results = await governorWrapper.submitTransactionAsync(data, destinations, signerAddresses[0]); const results = await governorWrapper.submitTransactionAsync(data, destinations, signerAddresses[0]);
const tx = governor.executeTransaction(results.txId).awaitTransactionSuccessAsync({ const tx = governor.executeTransaction(results.txId).awaitTransactionSuccessAsync({
@ -413,7 +413,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(tx).to.revertWith(RevertReason.TxNotFullyConfirmed); expect(tx).to.revertWith(RevertReason.TxNotFullyConfirmed);
}); });
it('should be able to execute an unregistered function after the default timelock with no value', async () => { it('should be able to execute an unregistered function after the default timelock with no value', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,
@ -424,7 +424,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId);
}); });
it('should be able to execute an unregistered function after the default timelock with a value', async () => { it('should be able to execute an unregistered function after the default timelock with a value', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const values = [INITIAL_BALANCE]; const values = [INITIAL_BALANCE];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
@ -437,7 +437,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values);
}); });
it('should be able to execute a registered function after a custom timelock with no value', async () => { it('should be able to execute a registered function after a custom timelock with no value', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2); const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2);
await governor await governor
@ -452,7 +452,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId);
}); });
it('should be able to execute a registered function with no timelock', async () => { it('should be able to execute a registered function with no timelock', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const newTimeLock = constants.ZERO_AMOUNT; const newTimeLock = constants.ZERO_AMOUNT;
await governor await governor
@ -467,7 +467,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId);
}); });
it('should be able to execute a registered function after a custom timelock with a value', async () => { it('should be able to execute a registered function after a custom timelock with a value', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2); const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2);
await governor await governor
@ -484,7 +484,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values);
}); });
it('should be able to call multiple functions with a single destination and no values', async () => { it('should be able to call multiple functions with a single destination and no values', async () => {
const data = [hexRandom(), hexRandom()]; const data = [hexUtils.random(), hexUtils.random()];
const destinations = [receiver.address, receiver.address]; const destinations = [receiver.address, receiver.address];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,
@ -501,7 +501,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
env.txDefaults, env.txDefaults,
{}, {},
); );
const data = [hexRandom(), hexRandom()]; const data = [hexUtils.random(), hexUtils.random()];
const destinations = [receiver.address, receiver2.address]; const destinations = [receiver.address, receiver2.address];
const values = [INITIAL_BALANCE.dividedToIntegerBy(4), INITIAL_BALANCE.dividedToIntegerBy(3)]; const values = [INITIAL_BALANCE.dividedToIntegerBy(4), INITIAL_BALANCE.dividedToIntegerBy(3)];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
@ -514,7 +514,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId, values);
}); });
it('should be able to call a combination of registered and unregistered functions', async () => { it('should be able to call a combination of registered and unregistered functions', async () => {
const data = [hexRandom(), hexRandom()]; const data = [hexUtils.random(), hexUtils.random()];
const destinations = [receiver.address, receiver.address]; const destinations = [receiver.address, receiver.address];
const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2); const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2);
await governor await governor
@ -529,7 +529,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId);
}); });
it('should fail if a single function has not passed the timelock', async () => { it('should fail if a single function has not passed the timelock', async () => {
const data = [hexRandom(), hexRandom()]; const data = [hexUtils.random(), hexUtils.random()];
const destinations = [receiver.address, receiver.address]; const destinations = [receiver.address, receiver.address];
const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2); const newTimeLock = new BigNumber(DEFAULT_TIME_LOCK).dividedToIntegerBy(2);
await governor await governor
@ -544,7 +544,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(tx).to.revertWith(RevertReason.DefaultTimeLockIncomplete); expect(tx).to.revertWith(RevertReason.DefaultTimeLockIncomplete);
}); });
it('should be able to execute a transaction if called by any address', async () => { it('should be able to execute a transaction if called by any address', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,
@ -579,7 +579,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId); assertReceiverCalledFromLogs(results.executionTxReceipt.logs, data, destinations, results.txId);
}); });
it('should revert if destinations.length != data.length', async () => { it('should revert if destinations.length != data.length', async () => {
const data = [hexRandom(), hexRandom()]; const data = [hexUtils.random(), hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync( const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,
@ -590,7 +590,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(tx).to.revertWith(RevertReason.EqualLengthsRequired); expect(tx).to.revertWith(RevertReason.EqualLengthsRequired);
}); });
it('should revert if values.length != data.length', async () => { it('should revert if values.length != data.length', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const values = [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT]; const values = [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT];
const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync( const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync(
@ -603,7 +603,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
expect(tx).to.revertWith(RevertReason.EqualLengthsRequired); expect(tx).to.revertWith(RevertReason.EqualLengthsRequired);
}); });
it('should revert if the transaction is already executed', async () => { it('should revert if the transaction is already executed', async () => {
const data = [hexRandom()]; const data = [hexUtils.random()];
const destinations = [receiver.address]; const destinations = [receiver.address];
const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync( const results = await governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,
@ -628,7 +628,7 @@ blockchainTests.resets('ZeroExGovernor', env => {
}); });
it('should revert if the any call is unsuccessful', async () => { it('should revert if the any call is unsuccessful', async () => {
const alwaysRevertSelector = '0xF1F2F3F4'; const alwaysRevertSelector = '0xF1F2F3F4';
const data = [hexRandom(), alwaysRevertSelector]; const data = [hexUtils.random(), alwaysRevertSelector];
const destinations = [receiver.address, receiver.address]; const destinations = [receiver.address, receiver.address];
const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync( const tx = governorWrapper.submitConfirmAndExecuteTransactionAsync(
data, data,

63
contracts/staking/test/unit_tests/delegator_reward_test.ts
View File

@ -3,13 +3,10 @@ import {
constants, constants,
expect, expect,
filterLogsToArguments, filterLogsToArguments,
hexHash,
hexRandom,
hexSlice,
Numberish, Numberish,
randomAddress, randomAddress,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { LogEntry } from 'ethereum-types'; import { LogEntry } from 'ethereum-types';
import { artifacts } from '../artifacts'; import { artifacts } from '../artifacts';
@ -47,7 +44,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
async function rewardPoolAsync(opts?: Partial<RewardPoolOpts>): Promise<RewardPoolOpts> { async function rewardPoolAsync(opts?: Partial<RewardPoolOpts>): Promise<RewardPoolOpts> {
const _opts = { const _opts = {
poolId: hexRandom(), poolId: hexUtils.random(),
operator: constants.NULL_ADDRESS, operator: constants.NULL_ADDRESS,
membersReward: getRandomInteger(1, toBaseUnitAmount(100)), membersReward: getRandomInteger(1, toBaseUnitAmount(100)),
operatorReward: getRandomInteger(1, toBaseUnitAmount(100)), operatorReward: getRandomInteger(1, toBaseUnitAmount(100)),
@ -79,7 +76,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
opts?: Partial<SetUnfinalizedMembersRewardsOpts>, opts?: Partial<SetUnfinalizedMembersRewardsOpts>,
): Promise<SetUnfinalizedMembersRewardsOpts> { ): Promise<SetUnfinalizedMembersRewardsOpts> {
const _opts = { const _opts = {
poolId: hexRandom(), poolId: hexUtils.random(),
operator: constants.NULL_ADDRESS, operator: constants.NULL_ADDRESS,
membersReward: getRandomInteger(1, toBaseUnitAmount(100)), membersReward: getRandomInteger(1, toBaseUnitAmount(100)),
operatorReward: getRandomInteger(1, toBaseUnitAmount(100)), operatorReward: getRandomInteger(1, toBaseUnitAmount(100)),
@ -107,7 +104,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
// Generates a deterministic operator address given a pool ID. // Generates a deterministic operator address given a pool ID.
function poolIdToOperator(poolId: string): string { function poolIdToOperator(poolId: string): string {
return hexSlice(hexHash(poolId), -20); return hexUtils.slice(hexUtils.hash(poolId), -20);
} }
// Converts pre-split rewards to the amounts the contracts will calculate // Converts pre-split rewards to the amounts the contracts will calculate
@ -320,7 +317,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('nothing in epoch 2 for delegator delegating in epoch 1', async () => { it('nothing in epoch 2 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
// rewards paid for stake in epoch 1. // rewards paid for stake in epoch 1.
@ -330,7 +327,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('all rewards from epoch 3 for delegator delegating in epoch 1', async () => { it('all rewards from epoch 3 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -341,7 +338,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('all rewards from epoch 3 and 3 for delegator delegating in epoch 1', async () => { it('all rewards from epoch 3 and 3 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -353,7 +350,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('partial rewards from epoch 3 and 3 for delegator partially delegating in epoch 1', async () => { it('partial rewards from epoch 3 and 3 for delegator partially delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake: delegatorStake } = await delegateStakeAsync(poolId); const { delegator, stake: delegatorStake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -368,7 +365,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('has correct reward immediately after undelegating', async () => { it('has correct reward immediately after undelegating', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -381,7 +378,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('has correct reward immediately after undelegating and redelegating', async () => { it('has correct reward immediately after undelegating and redelegating', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -395,7 +392,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('has correct reward immediately after undelegating, redelegating, and rewarding fees', async () => { it('has correct reward immediately after undelegating, redelegating, and rewarding fees', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -412,7 +409,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('ignores rewards paid in the same epoch the stake was first active in', async () => { it('ignores rewards paid in the same epoch the stake was first active in', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
// stake at 0 // stake at 0
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
@ -425,7 +422,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('uses old stake for rewards paid in the same epoch extra stake is added', async () => { it('uses old stake for rewards paid in the same epoch extra stake is added', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
// stake at 0 // stake at 0
const { delegator, stake: stake1 } = await delegateStakeAsync(poolId); const { delegator, stake: stake1 } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake1 now active) await advanceEpochAsync(); // epoch 2 (stake1 now active)
@ -453,7 +450,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('uses old stake for rewards paid in the epoch right after extra stake is added', async () => { it('uses old stake for rewards paid in the epoch right after extra stake is added', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
// stake at 0 // stake at 0
const { delegator, stake: stake1 } = await delegateStakeAsync(poolId); const { delegator, stake: stake1 } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake1 now active) await advanceEpochAsync(); // epoch 2 (stake1 now active)
@ -478,7 +475,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('computes correct rewards for 2 staggered delegators', async () => { it('computes correct rewards for 2 staggered delegators', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId); const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake A now active) await advanceEpochAsync(); // epoch 2 (stake A now active)
const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId); const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId);
@ -501,7 +498,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('computes correct rewards for 2 staggered delegators with a 2 epoch gap between payments', async () => { it('computes correct rewards for 2 staggered delegators with a 2 epoch gap between payments', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId); const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake A now active) await advanceEpochAsync(); // epoch 2 (stake A now active)
const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId); const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId);
@ -525,7 +522,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('correct rewards for rewards with different stakes', async () => { it('correct rewards for rewards with different stakes', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake: delegatorStake } = await delegateStakeAsync(poolId); const { delegator, stake: delegatorStake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -550,7 +547,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
describe('with unfinalized rewards', async () => { describe('with unfinalized rewards', async () => {
it('nothing with only unfinalized rewards from epoch 2 for delegator with nothing delegated', async () => { it('nothing with only unfinalized rewards from epoch 2 for delegator with nothing delegated', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId, { stake: 0 }); const { delegator, stake } = await delegateStakeAsync(poolId, { stake: 0 });
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await setUnfinalizedPoolRewardAsync({ poolId, membersStake: stake }); await setUnfinalizedPoolRewardAsync({ poolId, membersStake: stake });
@ -559,7 +556,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('nothing with only unfinalized rewards from epoch 2 for delegator delegating in epoch 1', async () => { it('nothing with only unfinalized rewards from epoch 2 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await setUnfinalizedPoolRewardAsync({ poolId, membersStake: stake }); await setUnfinalizedPoolRewardAsync({ poolId, membersStake: stake });
@ -568,7 +565,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('returns unfinalized rewards from epoch 3 for delegator delegating in epoch 1', async () => { it('returns unfinalized rewards from epoch 3 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -581,7 +578,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('returns unfinalized rewards from epoch 4 for delegator delegating in epoch 1', async () => { it('returns unfinalized rewards from epoch 4 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -595,7 +592,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('returns unfinalized rewards from epoch 4 + rewards from epoch 3 for delegator delegating in epoch 1', async () => { it('returns unfinalized rewards from epoch 4 + rewards from epoch 3 for delegator delegating in epoch 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -611,7 +608,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('returns unfinalized rewards from epoch 5 + rewards from epoch 3 for delegator delegating in epoch 2', async () => { it('returns unfinalized rewards from epoch 5 + rewards from epoch 3 for delegator delegating in epoch 2', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -628,7 +625,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('returns correct rewards if unfinalized stake is different from previous rewards', async () => { it('returns correct rewards if unfinalized stake is different from previous rewards', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 await advanceEpochAsync(); // epoch 2
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -657,7 +654,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
describe('reward transfers', async () => { describe('reward transfers', async () => {
it('transfers all rewards to delegator when touching stake', async () => { it('transfers all rewards to delegator when touching stake', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator, stake } = await delegateStakeAsync(poolId); const { delegator, stake } = await delegateStakeAsync(poolId);
await advanceEpochAsync(); // epoch 2 (stake now active) await advanceEpochAsync(); // epoch 2 (stake now active)
await advanceEpochAsync(); // epoch 3 await advanceEpochAsync(); // epoch 3
@ -670,7 +667,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('does not collect extra rewards from delegating more stake in the reward epoch', async () => { it('does not collect extra rewards from delegating more stake in the reward epoch', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const stakeResults = []; const stakeResults = [];
// stake // stake
stakeResults.push(await delegateStakeAsync(poolId)); stakeResults.push(await delegateStakeAsync(poolId));
@ -693,7 +690,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('only collects rewards from staked epochs', async () => { it('only collects rewards from staked epochs', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const stakeResults = []; const stakeResults = [];
// stake // stake
stakeResults.push(await delegateStakeAsync(poolId)); stakeResults.push(await delegateStakeAsync(poolId));
@ -724,7 +721,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('two delegators can collect split rewards as soon as available', async () => { it('two delegators can collect split rewards as soon as available', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId); const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId);
const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId); const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId);
const totalStake = BigNumber.sum(stakeA, stakeB); const totalStake = BigNumber.sum(stakeA, stakeB);
@ -741,7 +738,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('delegator B collects correct rewards after delegator A finalizes', async () => { it('delegator B collects correct rewards after delegator A finalizes', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId); const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId);
const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId); const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId);
const totalStake = BigNumber.sum(stakeA, stakeB); const totalStake = BigNumber.sum(stakeA, stakeB);
@ -765,7 +762,7 @@ blockchainTests.resets('Delegator rewards unit tests', env => {
}); });
it('delegator A and B collect correct rewards after external finalization', async () => { it('delegator A and B collect correct rewards after external finalization', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId); const { delegator: delegatorA, stake: stakeA } = await delegateStakeAsync(poolId);
const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId); const { delegator: delegatorB, stake: stakeB } = await delegateStakeAsync(poolId);
const totalStake = BigNumber.sum(stakeA, stakeB); const totalStake = BigNumber.sum(stakeA, stakeB);

17
contracts/staking/test/unit_tests/finalizer_test.ts
View File

@ -3,11 +3,10 @@ import {
constants, constants,
expect, expect,
filterLogsToArguments, filterLogsToArguments,
hexRandom,
Numberish, Numberish,
shortZip, shortZip,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber, StakingRevertErrors } from '@0x/utils'; import { BigNumber, hexUtils, StakingRevertErrors } from '@0x/utils';
import { LogEntry } from 'ethereum-types'; import { LogEntry } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -34,8 +33,8 @@ blockchainTests.resets('Finalizer unit tests', env => {
let testContract: TestFinalizerContract; let testContract: TestFinalizerContract;
before(async () => { before(async () => {
operatorRewardsReceiver = hexRandom(constants.ADDRESS_LENGTH); operatorRewardsReceiver = hexUtils.random(constants.ADDRESS_LENGTH);
membersRewardsReceiver = hexRandom(constants.ADDRESS_LENGTH); membersRewardsReceiver = hexUtils.random(constants.ADDRESS_LENGTH);
testContract = await TestFinalizerContract.deployFrom0xArtifactAsync( testContract = await TestFinalizerContract.deployFrom0xArtifactAsync(
artifacts.TestFinalizer, artifacts.TestFinalizer,
env.provider, env.provider,
@ -69,7 +68,7 @@ blockchainTests.resets('Finalizer unit tests', env => {
async function addActivePoolAsync(opts?: Partial<ActivePoolOpts>): Promise<ActivePoolOpts> { async function addActivePoolAsync(opts?: Partial<ActivePoolOpts>): Promise<ActivePoolOpts> {
const maxAmount = toBaseUnitAmount(1e9); const maxAmount = toBaseUnitAmount(1e9);
const _opts = { const _opts = {
poolId: hexRandom(), poolId: hexUtils.random(),
operatorShare: Math.floor(Math.random() * constants.PPM_DENOMINATOR) / constants.PPM_DENOMINATOR, operatorShare: Math.floor(Math.random() * constants.PPM_DENOMINATOR) / constants.PPM_DENOMINATOR,
feesCollected: getRandomInteger(0, maxAmount), feesCollected: getRandomInteger(0, maxAmount),
membersStake: getRandomInteger(0, maxAmount), membersStake: getRandomInteger(0, maxAmount),
@ -346,7 +345,7 @@ blockchainTests.resets('Finalizer unit tests', env => {
describe('_finalizePool()', () => { describe('_finalizePool()', () => {
it('does nothing if there were no pools to finalize', async () => { it('does nothing if there were no pools to finalize', async () => {
await testContract.endEpoch().awaitTransactionSuccessAsync(); await testContract.endEpoch().awaitTransactionSuccessAsync();
const poolId = hexRandom(); const poolId = hexUtils.random();
const logs = await finalizePoolsAsync([poolId]); const logs = await finalizePoolsAsync([poolId]);
expect(logs).to.deep.eq([]); expect(logs).to.deep.eq([]);
}); });
@ -459,7 +458,7 @@ blockchainTests.resets('Finalizer unit tests', env => {
}); });
it('rolls over leftover rewards into the next epoch', async () => { it('rolls over leftover rewards into the next epoch', async () => {
const poolIds = _.times(3, () => hexRandom()); const poolIds = _.times(3, () => hexUtils.random());
await Promise.all(poolIds.map(async id => addActivePoolAsync({ poolId: id }))); await Promise.all(poolIds.map(async id => addActivePoolAsync({ poolId: id })));
await testContract.endEpoch().awaitTransactionSuccessAsync(); await testContract.endEpoch().awaitTransactionSuccessAsync();
const finalizeLogs = await finalizePoolsAsync(poolIds); const finalizeLogs = await finalizePoolsAsync(poolIds);
@ -496,13 +495,13 @@ blockchainTests.resets('Finalizer unit tests', env => {
}; };
it('returns empty if epoch is 1', async () => { it('returns empty if epoch is 1', async () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS); return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS);
}); });
it('returns empty if pool did not earn rewards', async () => { it('returns empty if pool did not earn rewards', async () => {
await testContract.endEpoch().awaitTransactionSuccessAsync(); await testContract.endEpoch().awaitTransactionSuccessAsync();
const poolId = hexRandom(); const poolId = hexUtils.random();
return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS); return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS);
}); });

6
contracts/staking/test/unit_tests/lib_fixed_math_test.ts
View File

@ -1,5 +1,5 @@
import { blockchainTests, expect, hexRandom, Numberish } from '@0x/contracts-test-utils'; import { blockchainTests, expect, Numberish } from '@0x/contracts-test-utils';
import { BigNumber, FixedMathRevertErrors } from '@0x/utils'; import { BigNumber, FixedMathRevertErrors, hexUtils } from '@0x/utils';
import { Decimal } from 'decimal.js'; import { Decimal } from 'decimal.js';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -803,7 +803,7 @@ blockchainTests('LibFixedMath unit tests', env => {
function getRandomDecimal(min: Numberish, max: Numberish): BigNumber { function getRandomDecimal(min: Numberish, max: Numberish): BigNumber {
const range = new BigNumber(max).minus(min); const range = new BigNumber(max).minus(min);
const random = fromFixed(new BigNumber(hexRandom().substr(2), 16)); const random = fromFixed(new BigNumber(hexUtils.random().substr(2), 16));
return random.mod(range).plus(min); return random.mod(range).plus(min);
} }

5
contracts/staking/test/unit_tests/mixin_staking_pool_rewards.ts
View File

@ -5,12 +5,11 @@ import {
expect, expect,
getRandomInteger, getRandomInteger,
getRandomPortion, getRandomPortion,
hexRandom,
Numberish, Numberish,
randomAddress, randomAddress,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { LogEntry, TransactionReceiptWithDecodedLogs } from 'ethereum-types'; import { LogEntry, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
import { StoredBalance } from '../../src/types'; import { StoredBalance } from '../../src/types';
@ -21,7 +20,7 @@ import { TestMixinStakingPoolRewardsContract, TestMixinStakingPoolRewardsEvents
blockchainTests.resets('MixinStakingPoolRewards unit tests', env => { blockchainTests.resets('MixinStakingPoolRewards unit tests', env => {
let testContract: TestMixinStakingPoolRewardsContract; let testContract: TestMixinStakingPoolRewardsContract;
const POOL_ID = hexRandom(); const POOL_ID = hexUtils.random();
const OPERATOR = randomAddress(); const OPERATOR = randomAddress();
const OPERATOR_SHARE = getRandomInteger(1, constants.PPM_100_PERCENT); const OPERATOR_SHARE = getRandomInteger(1, constants.PPM_100_PERCENT);
let caller: string; let caller: string;

5
contracts/staking/test/unit_tests/protocol_fees_test.ts
View File

@ -3,11 +3,10 @@ import {
constants, constants,
expect, expect,
filterLogsToArguments, filterLogsToArguments,
hexRandom,
Numberish, Numberish,
randomAddress, randomAddress,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber, StakingRevertErrors } from '@0x/utils'; import { BigNumber, hexUtils, StakingRevertErrors } from '@0x/utils';
import { LogEntry } from 'ethereum-types'; import { LogEntry } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -56,7 +55,7 @@ blockchainTests('Protocol Fees unit tests', env => {
async function createTestPoolAsync(opts?: Partial<CreateTestPoolOpts>): Promise<CreateTestPoolOpts> { async function createTestPoolAsync(opts?: Partial<CreateTestPoolOpts>): Promise<CreateTestPoolOpts> {
const _opts = { const _opts = {
poolId: hexRandom(), poolId: hexUtils.random(),
operatorStake: getRandomInteger(minimumStake, '100e18'), operatorStake: getRandomInteger(minimumStake, '100e18'),
membersStake: getRandomInteger(minimumStake, '100e18'), membersStake: getRandomInteger(minimumStake, '100e18'),
makers: _.times(2, () => randomAddress()), makers: _.times(2, () => randomAddress()),

19
contracts/staking/test/unit_tests/stake_balances_test.ts
View File

@ -1,13 +1,6 @@
import { import { blockchainTests, constants, expect, getRandomInteger, randomAddress } from '@0x/contracts-test-utils';
blockchainTests,
constants,
expect,
getRandomInteger,
hexRandom,
randomAddress,
} from '@0x/contracts-test-utils';
import { SafeMathRevertErrors } from '@0x/contracts-utils'; import { SafeMathRevertErrors } from '@0x/contracts-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import { artifacts } from '../artifacts'; import { artifacts } from '../artifacts';
import { TestMixinStakeBalancesContract } from '../wrappers'; import { TestMixinStakeBalancesContract } from '../wrappers';
@ -170,8 +163,8 @@ blockchainTests.resets('MixinStakeBalances unit tests', env => {
describe('getStakeDelegatedToPoolByOwner()', () => { describe('getStakeDelegatedToPoolByOwner()', () => {
const staker = randomAddress(); const staker = randomAddress();
const notStaker = randomAddress(); const notStaker = randomAddress();
const poolId = hexRandom(); const poolId = hexUtils.random();
const notPoolId = hexRandom(); const notPoolId = hexUtils.random();
const delegatedBalance = randomStoredBalance(); const delegatedBalance = randomStoredBalance();
before(async () => { before(async () => {
@ -197,8 +190,8 @@ blockchainTests.resets('MixinStakeBalances unit tests', env => {
}); });
describe('getTotalStakeDelegatedToPool()', () => { describe('getTotalStakeDelegatedToPool()', () => {
const poolId = hexRandom(); const poolId = hexUtils.random();
const notPoolId = hexRandom(); const notPoolId = hexUtils.random();
const delegatedBalance = randomStoredBalance(); const delegatedBalance = randomStoredBalance();
before(async () => { before(async () => {

8
contracts/staking/test/unit_tests/stake_test.ts
View File

@ -4,12 +4,10 @@ import {
filterLogs, filterLogs,
filterLogsToArguments, filterLogsToArguments,
getRandomInteger, getRandomInteger,
hexLeftPad,
hexRandom,
Numberish, Numberish,
shortZip, shortZip,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { BigNumber, StakingRevertErrors } from '@0x/utils'; import { BigNumber, hexUtils, StakingRevertErrors } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { StakeStatus } from '../../src/types'; import { StakeStatus } from '../../src/types';
@ -157,8 +155,8 @@ blockchainTests.resets('MixinStake unit tests', env => {
describe('moveStake()', () => { describe('moveStake()', () => {
const INVALID_POOL_ERROR = 'INVALID_POOL'; const INVALID_POOL_ERROR = 'INVALID_POOL';
const INVALID_POOL_ID = hexLeftPad(0); const INVALID_POOL_ID = hexUtils.leftPad(0);
const VALID_POOL_IDS = [hexRandom(), hexRandom()]; const VALID_POOL_IDS = [hexUtils.random(), hexUtils.random()];
let delegatedStakeToPoolByOwnerSlots: string[]; let delegatedStakeToPoolByOwnerSlots: string[];
let delegatedStakeByPoolIdSlots: string[]; let delegatedStakeByPoolIdSlots: string[];
let globalDelegatedStakeSlot: string; let globalDelegatedStakeSlot: string;

11
contracts/staking/test/unit_tests/staking_pool_test.ts
View File

@ -3,13 +3,10 @@ import {
constants, constants,
expect, expect,
filterLogsToArguments, filterLogsToArguments,
hexLeftPad,
hexRandom,
toHex,
verifyEventsFromLogs, verifyEventsFromLogs,
} from '@0x/contracts-test-utils'; } from '@0x/contracts-test-utils';
import { SafeMathRevertErrors } from '@0x/contracts-utils'; import { SafeMathRevertErrors } from '@0x/contracts-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { StakingRevertErrors } from '../../src'; import { StakingRevertErrors } from '../../src';
@ -38,7 +35,7 @@ blockchainTests.resets('MixinStakingPool unit tests', env => {
}); });
function toNextPoolId(lastPoolId: string): string { function toNextPoolId(lastPoolId: string): string {
return hexLeftPad(new BigNumber(lastPoolId.slice(2), 16).plus(1)); return hexUtils.leftPad(new BigNumber(lastPoolId.slice(2), 16).plus(1));
} }
function randomOperatorShare(): number { function randomOperatorShare(): number {
@ -53,7 +50,7 @@ blockchainTests.resets('MixinStakingPool unit tests', env => {
async function createPoolAsync(opts?: Partial<CreatePoolOpts>): Promise<CreatePoolOpts> { async function createPoolAsync(opts?: Partial<CreatePoolOpts>): Promise<CreatePoolOpts> {
const _opts = { const _opts = {
poolId: hexRandom(), poolId: hexUtils.random(),
operator, operator,
operatorShare: randomOperatorShare(), operatorShare: randomOperatorShare(),
...opts, ...opts,
@ -99,7 +96,7 @@ blockchainTests.resets('MixinStakingPool unit tests', env => {
}); });
it('fails if the next pool ID overflows', async () => { it('fails if the next pool ID overflows', async () => {
await testContract.setLastPoolId(toHex(constants.MAX_UINT256)).awaitTransactionSuccessAsync(); await testContract.setLastPoolId(hexUtils.toHex(constants.MAX_UINT256)).awaitTransactionSuccessAsync();
const tx = testContract.createStakingPool(randomOperatorShare(), false).awaitTransactionSuccessAsync(); const tx = testContract.createStakingPool(randomOperatorShare(), false).awaitTransactionSuccessAsync();
const expectedError = new SafeMathRevertErrors.Uint256BinOpError( const expectedError = new SafeMathRevertErrors.Uint256BinOpError(
SafeMathRevertErrors.BinOpErrorCodes.AdditionOverflow, SafeMathRevertErrors.BinOpErrorCodes.AdditionOverflow,

11
contracts/test-utils/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "5.0.0",
"changes": [
{
"note": "Removed `hex_utils.ts`. Moved to @0x/utils",
"pr": 2373
}
]
},
{ {
"version": "4.0.0", "version": "4.0.0",
"changes": [ "changes": [
@ -63,7 +72,7 @@
"pr": 2031 "pr": 2031
}, },
{ {
"note": "Add `haxRandom()` to `hex_utils.ts`", "note": "Add `hexRandom()` to `hex_utils.ts`",
"pr": 2031 "pr": 2031
}, },
{ {

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

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

11
contracts/test-utils/src/index.ts
View File

@ -27,17 +27,6 @@ export { OrderFactory } from './order_factory';
export { bytes32Values, testCombinatoriallyWithReferenceFunc, uint256Values } from './combinatorial_utils'; export { bytes32Values, testCombinatoriallyWithReferenceFunc, uint256Values } from './combinatorial_utils';
export { TransactionFactory } from './transaction_factory'; export { TransactionFactory } from './transaction_factory';
export { testWithReferenceFuncAsync } from './test_with_reference'; export { testWithReferenceFuncAsync } from './test_with_reference';
export {
hexConcat,
hexHash,
hexLeftPad,
hexInvert,
hexSlice,
hexRandom,
hexRightPad,
hexSize,
toHex,
} from './hex_utils';
export { export {
BatchMatchOrder, BatchMatchOrder,
ContractName, ContractName,

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

@ -1,10 +1,9 @@
import { generatePseudoRandomSalt } from '@0x/order-utils'; import { generatePseudoRandomSalt } from '@0x/order-utils';
import { Order, SignedOrder } from '@0x/types'; import { Order, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber, hexUtils } from '@0x/utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { constants } from './constants'; import { constants } from './constants';
import { hexHash } from './hex_utils';
import { BatchMatchOrder, CancelOrder, MatchOrder } from './types'; import { BatchMatchOrder, CancelOrder, MatchOrder } from './types';
export const orderUtils = { export const orderUtils = {
@ -59,7 +58,7 @@ export const orderUtils = {
}, },
generatePseudoRandomOrderHash(): string { generatePseudoRandomOrderHash(): string {
const randomBigNum = generatePseudoRandomSalt(); const randomBigNum = generatePseudoRandomSalt();
const randomHash = hexHash(randomBigNum); const randomHash = hexUtils.hash(randomBigNum);
return randomHash; return randomHash;
}, },
}; };

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

@ -1,6 +1,6 @@
import { chaiSetup, constants, hexConcat, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils'; import { BlockchainLifecycle } from '@0x/dev-utils';
import { BigNumber, signTypedDataUtils } from '@0x/utils'; import { BigNumber, hexUtils, signTypedDataUtils } 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';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -48,7 +48,7 @@ describe('LibEIP712', () => {
const actualHash = await lib const actualHash = await lib
.externalHashEIP712DomainSeperator(name, version, new BigNumber(chainId), verifyingContract) .externalHashEIP712DomainSeperator(name, version, new BigNumber(chainId), verifyingContract)
.callAsync(); .callAsync();
expect(actualHash).to.be.eq(hexConcat(expectedHash)); expect(actualHash).to.be.eq(hexUtils.concat(expectedHash));
} }
describe('_hashEIP712Domain', async () => { describe('_hashEIP712Domain', async () => {

6
contracts/utils/test/lib_rich_errors.ts
View File

@ -1,5 +1,5 @@
import { blockchainTests, expect, hexRandom } from '@0x/contracts-test-utils'; import { blockchainTests, expect } from '@0x/contracts-test-utils';
import { coerceThrownErrorAsRevertError, StringRevertError } from '@0x/utils'; import { coerceThrownErrorAsRevertError, hexUtils, StringRevertError } from '@0x/utils';
import { artifacts } from './artifacts'; import { artifacts } from './artifacts';
import { TestLibRichErrorsContract } from './wrappers'; import { TestLibRichErrorsContract } from './wrappers';
@ -19,7 +19,7 @@ blockchainTests('LibRichErrors', env => {
describe('_rrevert', () => { describe('_rrevert', () => {
it('should correctly revert the extra bytes', async () => { it('should correctly revert the extra bytes', async () => {
const extraBytes = hexRandom(100); const extraBytes = hexUtils.random(100);
try { try {
await lib.externalRRevert(extraBytes).callAsync(); await lib.externalRRevert(extraBytes).callAsync();
} catch (err) { } catch (err) {

7
packages/0x.js/src/index.ts
View File

@ -1,6 +1,6 @@
export { getContractAddressesForChainOrThrow, ChainId, ContractAddresses } from '@0x/contract-addresses'; export { getContractAddressesForChainOrThrow, ChainId, ContractAddresses } from '@0x/contract-addresses';
export { assetDataUtils, signatureUtils, generatePseudoRandomSalt } from '@0x/order-utils'; export { signatureUtils, generatePseudoRandomSalt, decodeAssetDataOrThrow } from '@0x/order-utils';
export { export {
ExchangeEventArgs, ExchangeEventArgs,
@ -60,14 +60,15 @@ export {
Order, Order,
SignedOrder, SignedOrder,
ECSignature, ECSignature,
AssetProxyId, AssetData,
SingleAssetData, SingleAssetData,
ERC20AssetData, ERC20AssetData,
ERC20BridgeAssetData,
ERC721AssetData, ERC721AssetData,
ERC1155AssetData, ERC1155AssetData,
MultiAssetData, MultiAssetData,
MultiAssetDataWithRecursiveDecoding,
StaticCallAssetData, StaticCallAssetData,
MultiAssetDataWithRecursiveDecoding,
SignatureType, SignatureType,
ZeroExTransaction, ZeroExTransaction,
SignedZeroExTransaction, SignedZeroExTransaction,

13
packages/asset-swapper/test/order_prune_utils_test.ts
View File

@ -3,7 +3,6 @@ import { DevUtilsContract, ERC20TokenContract, ExchangeContract } from '@0x/cont
import { constants as devConstants, getLatestBlockTimestampAsync, OrderFactory } from '@0x/contracts-test-utils'; import { constants as devConstants, getLatestBlockTimestampAsync, OrderFactory } from '@0x/contracts-test-utils';
import { BlockchainLifecycle, tokenUtils } from '@0x/dev-utils'; import { BlockchainLifecycle, tokenUtils } from '@0x/dev-utils';
import { migrateOnceAsync } from '@0x/migrations'; import { migrateOnceAsync } from '@0x/migrations';
import { assetDataUtils } from '@0x/order-utils';
import { SignedOrder } from '@0x/types'; import { SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
@ -70,13 +69,15 @@ describe('OrderPruner', () => {
[makerTokenAddress, takerTokenAddress] = tokenUtils.getDummyERC20TokenAddresses(); [makerTokenAddress, takerTokenAddress] = tokenUtils.getDummyERC20TokenAddresses();
erc20MakerTokenContract = new ERC20TokenContract(makerTokenAddress, provider); erc20MakerTokenContract = new ERC20TokenContract(makerTokenAddress, provider);
erc20TakerTokenContract = new ERC20TokenContract(takerTokenAddress, provider); erc20TakerTokenContract = new ERC20TokenContract(takerTokenAddress, provider);
[makerAssetData, takerAssetData, wethAssetData] = [
assetDataUtils.encodeERC20AssetData(makerTokenAddress),
assetDataUtils.encodeERC20AssetData(takerTokenAddress),
assetDataUtils.encodeERC20AssetData(contractAddresses.etherToken),
];
exchangeContract = new ExchangeContract(contractAddresses.exchange, provider); exchangeContract = new ExchangeContract(contractAddresses.exchange, provider);
devUtilsContract = new DevUtilsContract(contractAddresses.devUtils, provider); devUtilsContract = new DevUtilsContract(contractAddresses.devUtils, provider);
[makerAssetData, takerAssetData, wethAssetData] = [
await devUtilsContract.encodeERC20AssetData(makerTokenAddress).callAsync(),
await devUtilsContract.encodeERC20AssetData(takerTokenAddress).callAsync(),
await devUtilsContract.encodeERC20AssetData(contractAddresses.etherToken).callAsync(),
];
// Configure order defaults // Configure order defaults
const defaultOrderParams = { const defaultOrderParams = {
...devConstants.STATIC_ORDER_PARAMS, ...devConstants.STATIC_ORDER_PARAMS,

9
packages/contract-artifacts/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "3.1.0",
"changes": [
{
"note": "Add `IAssetData` artifact",
"pr": 2373
}
]
},
{ {
"version": "3.0.0", "version": "3.0.0",
"changes": [ "changes": [

251
packages/contract-artifacts/artifacts/IAssetData.json generated Normal file
View File

@ -0,0 +1,251 @@
{
"schemaVersion": "2.0.0",
"contractName": "IAssetData",
"compilerOutput": {
"abi": [
{
"constant": false,
"inputs": [
{
"internalType": "address",
"name": "tokenAddress",
"type": "address"
},
{
"internalType": "uint256[]",
"name": "tokenIds",
"type": "uint256[]"
},
{
"internalType": "uint256[]",
"name": "values",
"type": "uint256[]"
},
{
"internalType": "bytes",
"name": "callbackData",
"type": "bytes"
}
],
"name": "ERC1155Assets",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"internalType": "address",
"name": "tokenAddress",
"type": "address"
},
{
"internalType": "address",
"name": "bridgeAddress",
"type": "address"
},
{
"internalType": "bytes",
"name": "bridgeData",
"type": "bytes"
}
],
"name": "ERC20Bridge",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"internalType": "address",
"name": "tokenAddress",
"type": "address"
}
],
"name": "ERC20Token",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"internalType": "address",
"name": "tokenAddress",
"type": "address"
},
{
"internalType": "uint256",
"name": "tokenId",
"type": "uint256"
}
],
"name": "ERC721Token",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"internalType": "uint256[]",
"name": "values",
"type": "uint256[]"
},
{
"internalType": "bytes[]",
"name": "nestedAssetData",
"type": "bytes[]"
}
],
"name": "MultiAsset",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"internalType": "address",
"name": "staticCallTargetAddress",
"type": "address"
},
{
"internalType": "bytes",
"name": "staticCallData",
"type": "bytes"
},
{
"internalType": "bytes32",
"name": "expectedReturnDataHash",
"type": "bytes32"
}
],
"name": "StaticCall",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
}
],
"devdoc": {
"methods": {
"ERC1155Assets(address,uint256[],uint256[],bytes)": {
"details": "Function signature for encoding ERC1155 assetData.",
"params": {
"callbackData": "Extra data to be passed to receiver's `onERC1155Received` callback function.",
"tokenAddress": "Address of ERC1155 token contract.",
"tokenIds": "Array of ids of tokens to be transferred.",
"values": "Array of values that correspond to each token id to be transferred. Note that each value will be multiplied by the amount being filled in the order before transferring."
}
},
"ERC20Bridge(address,address,bytes)": {
"details": "Function signature for encoding ERC20Bridge assetData.",
"params": {
"bridgeAddress": "Address of the bridge contract.",
"bridgeData": "Arbitrary data to be passed to the bridge contract.",
"tokenAddress": "Address of token to transfer."
}
},
"ERC20Token(address)": {
"details": "Function signature for encoding ERC20 assetData.",
"params": {
"tokenAddress": "Address of ERC20Token contract."
}
},
"ERC721Token(address,uint256)": {
"details": "Function signature for encoding ERC721 assetData.",
"params": {
"tokenAddress": "Address of ERC721 token contract.",
"tokenId": "Id of ERC721 token to be transferred."
}
},
"MultiAsset(uint256[],bytes[])": {
"details": "Function signature for encoding MultiAsset assetData.",
"params": {
"nestedAssetData": "Array of assetData fields that will be be dispatched to their correspnding AssetProxy contract.",
"values": "Array of amounts that correspond to each asset to be transferred. Note that each value will be multiplied by the amount being filled in the order before transferring."
}
},
"StaticCall(address,bytes,bytes32)": {
"details": "Function signature for encoding StaticCall assetData.",
"params": {
"expectedReturnDataHash": "Keccak-256 hash of the expected staticcall return data.",
"staticCallData": "Data that will be executed via staticcall on the staticCallTargetAddress.",
"staticCallTargetAddress": "Address that will execute the staticcall."
}
}
}
},
"evm": {
"bytecode": {
"linkReferences": {},
"object": "0x",
"opcodes": "",
"sourceMap": ""
},
"deployedBytecode": {
"linkReferences": {},
"object": "0x",
"opcodes": "",
"sourceMap": ""
}
}
},
"sources": {
"src/interfaces/IAssetData.sol": {
"id": 11
}
},
"sourceCodes": {
"src/interfaces/IAssetData.sol": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\n// solhint-disable\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\n\n// @dev Interface of the asset proxy's assetData.\n// The asset proxies take an ABI encoded `bytes assetData` as argument.\n// This argument is ABI encoded as one of the methods of this interface.\ninterface IAssetData {\n\n /// @dev Function signature for encoding ERC20 assetData.\n /// @param tokenAddress Address of ERC20Token contract.\n function ERC20Token(address tokenAddress)\n external;\n\n /// @dev Function signature for encoding ERC721 assetData.\n /// @param tokenAddress Address of ERC721 token contract.\n /// @param tokenId Id of ERC721 token to be transferred.\n function ERC721Token(\n address tokenAddress,\n uint256 tokenId\n )\n external;\n\n /// @dev Function signature for encoding ERC1155 assetData.\n /// @param tokenAddress Address of ERC1155 token contract.\n /// @param tokenIds Array of ids of tokens to be transferred.\n /// @param values Array of values that correspond to each token id to be transferred.\n /// Note that each value will be multiplied by the amount being filled in the order before transferring.\n /// @param callbackData Extra data to be passed to receiver's `onERC1155Received` callback function.\n function ERC1155Assets(\n address tokenAddress,\n uint256[] calldata tokenIds,\n uint256[] calldata values,\n bytes calldata callbackData\n )\n external;\n\n /// @dev Function signature for encoding MultiAsset assetData.\n /// @param values Array of amounts that correspond to each asset to be transferred.\n /// Note that each value will be multiplied by the amount being filled in the order before transferring.\n /// @param nestedAssetData Array of assetData fields that will be be dispatched to their correspnding AssetProxy contract.\n function MultiAsset(\n uint256[] calldata values,\n bytes[] calldata nestedAssetData\n )\n external;\n\n /// @dev Function signature for encoding StaticCall assetData.\n /// @param staticCallTargetAddress Address that will execute the staticcall.\n /// @param staticCallData Data that will be executed via staticcall on the staticCallTargetAddress.\n /// @param expectedReturnDataHash Keccak-256 hash of the expected staticcall return data.\n function StaticCall(\n address staticCallTargetAddress,\n bytes calldata staticCallData,\n bytes32 expectedReturnDataHash\n )\n external;\n\n /// @dev Function signature for encoding ERC20Bridge assetData.\n /// @param tokenAddress Address of token to transfer.\n /// @param bridgeAddress Address of the bridge contract.\n /// @param bridgeData Arbitrary data to be passed to the bridge contract.\n function ERC20Bridge(\n address tokenAddress,\n address bridgeAddress,\n bytes calldata bridgeData\n )\n external;\n}\n"
},
"sourceTreeHashHex": "0x3ceff1522c201d446ee98d9ecd912ad2ca6adc6fae9fc10d458ff557d570decc",
"compiler": {
"name": "solc",
"version": "soljson-v0.5.13+commit.5b0b510c.js",
"settings": {
"optimizer": {
"enabled": true,
"runs": 1000000,
"details": {
"yul": true,
"deduplicate": true,
"cse": true,
"constantOptimizer": true
}
},
"outputSelection": {
"*": {
"*": [
"abi",
"devdoc",
"evm.bytecode.object",
"evm.bytecode.sourceMap",
"evm.deployedBytecode.object",
"evm.deployedBytecode.sourceMap"
]
}
},
"evmVersion": "constantinople",
"remappings": [
"@0x/contracts-utils=/Users/xianny/src/copy-0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils",
"@0x/contracts-erc1155=/Users/xianny/src/copy-0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc1155",
"@0x/contracts-erc20=/Users/xianny/src/copy-0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc20",
"@0x/contracts-exchange-libs=/Users/xianny/src/copy-0x-monorepo/node_modules/@0x/contracts-exchange-libs"
]
}
},
"chains": {}
}

9
packages/contract-wrappers/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "13.1.0",
"changes": [
{
"note": "Add wrapper for `IAssetDataContract`",
"pr": 2373
}
]
},
{ {
"version": "13.0.0", "version": "13.0.0",
"changes": [ "changes": [

2
packages/contract-wrappers/package.json
View File

@ -31,7 +31,7 @@
"wrappers:generate": "abi-gen --abis ${npm_package_config_abis} --output src/generated-wrappers --backend ethers" "wrappers:generate": "abi-gen --abis ${npm_package_config_abis} --output src/generated-wrappers --backend ethers"
}, },
"config": { "config": {
"abis": "../contract-artifacts/artifacts/@(DevUtils|ERC20Token|ERC721Token|Exchange|Forwarder|WETH9|Coordinator|Staking|StakingProxy).json" "abis": "../contract-artifacts/artifacts/@(DevUtils|ERC20Token|ERC721Token|Exchange|Forwarder|IAssetData|WETH9|Coordinator|Staking|StakingProxy).json"
}, },
"repository": { "repository": {
"type": "git", "type": "git",

643
packages/contract-wrappers/src/generated-wrappers/i_asset_data.ts generated Normal file
View File

@ -0,0 +1,643 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma enum-naming
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable
import {
AwaitTransactionSuccessOpts,
ContractFunctionObj,
ContractTxFunctionObj,
SendTransactionOpts,
BaseContract,
PromiseWithTransactionHash,
methodAbiToFunctionSignature,
} from '@0x/base-contract';
import { schemas } from '@0x/json-schemas';
import {
BlockParam,
BlockParamLiteral,
BlockRange,
CallData,
ContractAbi,
ContractArtifact,
DecodedLogArgs,
MethodAbi,
TransactionReceiptWithDecodedLogs,
TxData,
TxDataPayable,
SupportedProvider,
} from 'ethereum-types';
import { BigNumber, classUtils, logUtils, providerUtils } from '@0x/utils';
import { EventCallback, IndexedFilterValues, SimpleContractArtifact } from '@0x/types';
import { Web3Wrapper } from '@0x/web3-wrapper';
import { assert } from '@0x/assert';
import * as ethers from 'ethers';
// tslint:enable:no-unused-variable
/* istanbul ignore next */
// tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name
export class IAssetDataContract extends BaseContract {
/**
* @ignore
*/
public static deployedBytecode: string | undefined;
private readonly _methodABIIndex: { [name: string]: number } = {};
public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact },
): Promise<IAssetDataContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
schemas.jsNumber,
]);
if (artifact.compilerOutput === undefined) {
throw new Error('Compiler output not found in the artifact file');
}
const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly: { [contractName: string]: ContractAbi } = {};
if (Object.keys(logDecodeDependencies) !== undefined) {
for (const key of Object.keys(logDecodeDependencies)) {
logDecodeDependenciesAbiOnly[key] = logDecodeDependencies[key].compilerOutput.abi;
}
}
return IAssetDataContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly);
}
public static async deployAsync(
bytecode: string,
abi: ContractAbi,
supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractAbi },
): Promise<IAssetDataContract> {
assert.isHexString('bytecode', bytecode);
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
schemas.jsNumber,
]);
const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString);
const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToContractTxDataAsync(
{
data: txData,
...txDefaults,
},
web3Wrapper.estimateGasAsync.bind(web3Wrapper),
);
const txHash = await web3Wrapper.sendTransactionAsync(txDataWithDefaults);
logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`IAssetData successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new IAssetDataContract(
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = [];
return contractInstance;
}
/**
* @returns The contract ABI
*/
public static ABI(): ContractAbi {
const abi = [
{
constant: false,
inputs: [
{
name: 'tokenAddress',
type: 'address',
},
{
name: 'tokenIds',
type: 'uint256[]',
},
{
name: 'values',
type: 'uint256[]',
},
{
name: 'callbackData',
type: 'bytes',
},
],
name: 'ERC1155Assets',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'tokenAddress',
type: 'address',
},
{
name: 'bridgeAddress',
type: 'address',
},
{
name: 'bridgeData',
type: 'bytes',
},
],
name: 'ERC20Bridge',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'tokenAddress',
type: 'address',
},
],
name: 'ERC20Token',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'tokenAddress',
type: 'address',
},
{
name: 'tokenId',
type: 'uint256',
},
],
name: 'ERC721Token',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'values',
type: 'uint256[]',
},
{
name: 'nestedAssetData',
type: 'bytes[]',
},
],
name: 'MultiAsset',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
{
constant: false,
inputs: [
{
name: 'staticCallTargetAddress',
type: 'address',
},
{
name: 'staticCallData',
type: 'bytes',
},
{
name: 'expectedReturnDataHash',
type: 'bytes32',
},
],
name: 'StaticCall',
outputs: [],
payable: false,
stateMutability: 'nonpayable',
type: 'function',
},
] as ContractAbi;
return abi;
}
public getFunctionSignature(methodName: string): string {
const index = this._methodABIIndex[methodName];
const methodAbi = IAssetDataContract.ABI()[index] as MethodAbi; // tslint:disable-line:no-unnecessary-type-assertion
const functionSignature = methodAbiToFunctionSignature(methodAbi);
return functionSignature;
}
public getABIDecodedTransactionData<T>(methodName: string, callData: string): T {
const functionSignature = this.getFunctionSignature(methodName);
const self = (this as any) as IAssetDataContract;
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const abiDecodedCallData = abiEncoder.strictDecode<T>(callData);
return abiDecodedCallData;
}
public getABIDecodedReturnData<T>(methodName: string, callData: string): T {
const functionSignature = this.getFunctionSignature(methodName);
const self = (this as any) as IAssetDataContract;
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const abiDecodedCallData = abiEncoder.strictDecodeReturnValue<T>(callData);
return abiDecodedCallData;
}
public getSelector(methodName: string): string {
const functionSignature = this.getFunctionSignature(methodName);
const self = (this as any) as IAssetDataContract;
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.getSelector();
}
/**
* Function signature for encoding ERC1155 assetData.
* @param tokenAddress Address of ERC1155 token contract.
* @param tokenIds Array of ids of tokens to be transferred.
* @param values Array of values that correspond to each token id to be
* transferred. Note that each value will be multiplied by the
* amount being filled in the order before transferring.
* @param callbackData Extra data to be passed to receiver's
* `onERC1155Received` callback function.
*/
public ERC1155Assets(
tokenAddress: string,
tokenIds: BigNumber[],
values: BigNumber[],
callbackData: string,
): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isString('tokenAddress', tokenAddress);
assert.isArray('tokenIds', tokenIds);
assert.isArray('values', values);
assert.isString('callbackData', callbackData);
const functionSignature = 'ERC1155Assets(address,uint256[],uint256[],bytes)';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [
tokenAddress.toLowerCase(),
tokenIds,
values,
callbackData,
]);
},
};
}
/**
* Function signature for encoding ERC20Bridge assetData.
* @param tokenAddress Address of token to transfer.
* @param bridgeAddress Address of the bridge contract.
* @param bridgeData Arbitrary data to be passed to the bridge contract.
*/
public ERC20Bridge(tokenAddress: string, bridgeAddress: string, bridgeData: string): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isString('tokenAddress', tokenAddress);
assert.isString('bridgeAddress', bridgeAddress);
assert.isString('bridgeData', bridgeData);
const functionSignature = 'ERC20Bridge(address,address,bytes)';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [
tokenAddress.toLowerCase(),
bridgeAddress.toLowerCase(),
bridgeData,
]);
},
};
}
/**
* Function signature for encoding ERC20 assetData.
* @param tokenAddress Address of ERC20Token contract.
*/
public ERC20Token(tokenAddress: string): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isString('tokenAddress', tokenAddress);
const functionSignature = 'ERC20Token(address)';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [tokenAddress.toLowerCase()]);
},
};
}
/**
* Function signature for encoding ERC721 assetData.
* @param tokenAddress Address of ERC721 token contract.
* @param tokenId Id of ERC721 token to be transferred.
*/
public ERC721Token(tokenAddress: string, tokenId: BigNumber): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isString('tokenAddress', tokenAddress);
assert.isBigNumber('tokenId', tokenId);
const functionSignature = 'ERC721Token(address,uint256)';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [tokenAddress.toLowerCase(), tokenId]);
},
};
}
/**
* Function signature for encoding MultiAsset assetData.
* @param values Array of amounts that correspond to each asset to be
* transferred. Note that each value will be multiplied by the
* amount being filled in the order before transferring.
* @param nestedAssetData Array of assetData fields that will be be dispatched
* to their correspnding AssetProxy contract.
*/
public MultiAsset(values: BigNumber[], nestedAssetData: string[]): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isArray('values', values);
assert.isArray('nestedAssetData', nestedAssetData);
const functionSignature = 'MultiAsset(uint256[],bytes[])';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [values, nestedAssetData]);
},
};
}
/**
* Function signature for encoding StaticCall assetData.
* @param staticCallTargetAddress Address that will execute the staticcall.
* @param staticCallData Data that will be executed via staticcall on the
* staticCallTargetAddress.
* @param expectedReturnDataHash Keccak-256 hash of the expected staticcall
* return data.
*/
public StaticCall(
staticCallTargetAddress: string,
staticCallData: string,
expectedReturnDataHash: string,
): ContractTxFunctionObj<void> {
const self = (this as any) as IAssetDataContract;
assert.isString('staticCallTargetAddress', staticCallTargetAddress);
assert.isString('staticCallData', staticCallData);
assert.isString('expectedReturnDataHash', expectedReturnDataHash);
const functionSignature = 'StaticCall(address,bytes,bytes32)';
return {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this),
);
if (opts.shouldValidate !== false) {
await this.callAsync(txDataWithDefaults);
}
return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
},
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
},
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock);
const rawCallResult = await self._performCallAsync(
{ ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
},
getABIEncodedTransactionData(): string {
return self._strictEncodeArguments(functionSignature, [
staticCallTargetAddress.toLowerCase(),
staticCallData,
expectedReturnDataHash,
]);
},
};
}
constructor(
address: string,
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
deployedBytecode: string | undefined = IAssetDataContract.deployedBytecode,
) {
super(
'IAssetData',
IAssetDataContract.ABI(),
address,
supportedProvider,
txDefaults,
logDecodeDependencies,
deployedBytecode,
);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
IAssetDataContract.ABI().forEach((item, index) => {
if (item.type === 'function') {
const methodAbi = item as MethodAbi;
this._methodABIIndex[methodAbi.name] = index;
}
});
}
}
// tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method no-parameter-reassignment no-consecutive-blank-lines ordered-imports align
// tslint:enable:trailing-comma whitespace no-trailing-whitespace

1
packages/contract-wrappers/src/index.ts
View File

@ -2,6 +2,7 @@ export { ContractAddresses } from '@0x/contract-addresses';
export { ContractWrappers } from './contract_wrappers'; export { ContractWrappers } from './contract_wrappers';
export { DevUtilsContract } from './generated-wrappers/dev_utils'; export { DevUtilsContract } from './generated-wrappers/dev_utils';
export { IAssetDataContract } from './generated-wrappers/i_asset_data'; // used for synchronously encoding and decoding asset data
export { export {
ERC20TokenEventArgs, ERC20TokenEventArgs,
ERC20TokenEvents, ERC20TokenEvents,

2
packages/instant/package.json
View File

@ -45,8 +45,8 @@
"dependencies": { "dependencies": {
"@0x/assert": "^3.0.0", "@0x/assert": "^3.0.0",
"@0x/asset-swapper": "^3.0.0", "@0x/asset-swapper": "^3.0.0",
"@0x/contract-wrappers": "13.0.0",
"@0x/json-schemas": "^5.0.0", "@0x/json-schemas": "^5.0.0",
"@0x/order-utils": "^9.0.0",
"@0x/subproviders": "^6.0.0", "@0x/subproviders": "^6.0.0",
"@0x/utils": "^5.0.0", "@0x/utils": "^5.0.0",
"@0x/web3-wrapper": "^7.0.0", "@0x/web3-wrapper": "^7.0.0",

6
packages/instant/src/index.umd.ts
View File

@ -1,5 +1,4 @@
import { BigNumber, SwapQuoter } from '@0x/asset-swapper'; import { BigNumber, SwapQuoter } from '@0x/asset-swapper';
import { assetDataUtils } from '@0x/order-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { providerUtils } from '@0x/utils'; import { providerUtils } from '@0x/utils';
import { SupportedProvider, ZeroExProvider } from 'ethereum-types'; import { SupportedProvider, ZeroExProvider } from 'ethereum-types';
@ -19,6 +18,7 @@ import { ZeroExInstantOverlay, ZeroExInstantOverlayProps } from './index';
import { Network, OrderSource } from './types'; import { Network, OrderSource } from './types';
import { analytics } from './util/analytics'; import { analytics } from './util/analytics';
import { assert } from './util/assert'; import { assert } from './util/assert';
import { assetDataEncoder } from './util/asset_data_encoder';
import { orderCoercionUtil } from './util/order_coercion'; import { orderCoercionUtil } from './util/order_coercion';
import { providerFactory } from './util/provider_factory'; import { providerFactory } from './util/provider_factory';
import { util } from './util/util'; import { util } from './util/util';
@ -158,12 +158,12 @@ export const ERC20_PROXY_ID = AssetProxyId.ERC20;
export const assetDataForERC20TokenAddress = (tokenAddress: string): string => { export const assetDataForERC20TokenAddress = (tokenAddress: string): string => {
assert.isETHAddressHex('tokenAddress', tokenAddress); assert.isETHAddressHex('tokenAddress', tokenAddress);
return assetDataUtils.encodeERC20AssetData(tokenAddress); return assetDataEncoder.ERC20Token(tokenAddress).getABIEncodedTransactionData();
}; };
export const assetDataForERC721TokenAddress = (tokenAddress: string, tokenId: string | number): string => { export const assetDataForERC721TokenAddress = (tokenAddress: string, tokenId: string | number): string => {
assert.isETHAddressHex('tokenAddress', tokenAddress); assert.isETHAddressHex('tokenAddress', tokenAddress);
return assetDataUtils.encodeERC721AssetData(tokenAddress, new BigNumber(tokenId)); return assetDataEncoder.ERC721Token(tokenAddress, new BigNumber(tokenId)).getABIEncodedTransactionData();
}; };
export const hasMetaDataForAssetData = (assetData: string): boolean => { export const hasMetaDataForAssetData = (assetData: string): boolean => {

5
packages/instant/src/util/assert.ts
View File

@ -1,11 +1,12 @@
import { assert as sharedAssert } from '@0x/assert'; import { assert as sharedAssert } from '@0x/assert';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { assetDataUtils } from '@0x/order-utils';
import { AssetProxyId, ObjectMap, SignedOrder } from '@0x/types'; import { AssetProxyId, ObjectMap, SignedOrder } from '@0x/types';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { AffiliateInfo, AssetMetaData } from '../types'; import { AffiliateInfo, AssetMetaData } from '../types';
import { decodeAssetProxyId } from './asset_data_encoder';
export const assert = { export const assert = {
...sharedAssert, ...sharedAssert,
isValidOrderSource(variableName: string, orderSource: string | SignedOrder[]): void { isValidOrderSource(variableName: string, orderSource: string | SignedOrder[]): void {
@ -22,7 +23,7 @@ export const assert = {
_.forEach(metaDataMap, (metaData, assetData) => { _.forEach(metaDataMap, (metaData, assetData) => {
assert.isHexString(`key ${assetData} of ${variableName}`, assetData); assert.isHexString(`key ${assetData} of ${variableName}`, assetData);
assert.isValidAssetMetaData(`${variableName}.${assetData}`, metaData); assert.isValidAssetMetaData(`${variableName}.${assetData}`, metaData);
const assetDataProxyId = assetDataUtils.decodeAssetProxyId(assetData); const assetDataProxyId = decodeAssetProxyId(assetData);
assert.assert( assert.assert(
metaData.assetProxyId === assetDataProxyId, metaData.assetProxyId === assetDataProxyId,
`Expected meta data for assetData ${assetData} to have asset proxy id of ${assetDataProxyId}, but instead got ${ `Expected meta data for assetData ${assetData} to have asset proxy id of ${assetDataProxyId}, but instead got ${

19
packages/instant/src/util/asset_data_encoder.ts Normal file
View File

@ -0,0 +1,19 @@
import { IAssetDataContract } from '@0x/contract-wrappers';
import { hexUtils, NULL_ADDRESS } from '@0x/utils';
const fakeProvider = { isEIP1193: true } as any;
// instantiate once per app to be more performant
export const assetDataEncoder = new IAssetDataContract(NULL_ADDRESS, fakeProvider);
/**
* Returns the first four bytes of a given hex string.
* Does not have any validations, so the hex string MUST
* be a valid asset data, or this function returns garbage
* without throwing errors.
* @param assetData A hex string where the first four bytes are a valid Asset Proxy Id
*
*/
export function decodeAssetProxyId(assetData: string): string {
return hexUtils.slice(assetData, 0, 4);
}

13
packages/order-utils/CHANGELOG.json
View File

@ -1,4 +1,17 @@
[ [
{
"version": "10.0.0",
"changes": [
{
"note": "Removed `assetDataUtils`",
"pr": 2373
},
{
"note": "Exported function `decodeAssetDataOrThrow`",
"pr": 2373
}
]
},
{ {
"version": "9.0.0", "version": "9.0.0",
"changes": [ "changes": [

469
packages/order-utils/src/asset_data_utils.ts
View File

@ -1,469 +0,0 @@
import {
AssetProxyId,
ERC1155AssetData,
ERC1155AssetDataNoProxyId,
ERC20AssetData,
ERC721AssetData,
MultiAssetData,
MultiAssetDataWithRecursiveDecoding,
SingleAssetData,
StaticCallAssetData,
} from '@0x/types';
import { AbiEncoder, BigNumber } from '@0x/utils';
import * as _ from 'lodash';
import { constants } from './constants';
const encodingRules: AbiEncoder.EncodingRules = { shouldOptimize: true };
const decodingRules: AbiEncoder.DecodingRules = { shouldConvertStructsToObjects: true };
export const assetDataUtils = {
/**
* Encodes an ERC20 token address into a hex encoded assetData string, usable in the makerAssetData or
* takerAssetData fields in a 0x order.
* @param tokenAddress The ERC20 token address to encode
* @return The hex encoded assetData string
*/
encodeERC20AssetData(tokenAddress: string): string {
const abiEncoder = new AbiEncoder.Method(constants.ERC20_METHOD_ABI);
const args = [tokenAddress];
const assetData = abiEncoder.encode(args, encodingRules);
return assetData;
},
/**
* Decodes an ERC20 assetData hex string into its corresponding ERC20 tokenAddress & assetProxyId
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded tokenAddress & assetProxyId
*/
decodeERC20AssetData(assetData: string): ERC20AssetData {
assetDataUtils.assertIsERC20AssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
const abiEncoder = new AbiEncoder.Method(constants.ERC20_METHOD_ABI);
const decodedAssetData = abiEncoder.decode(assetData, decodingRules);
return {
assetProxyId,
// TODO(abandeali1): fix return types for `AbiEncoder.Method.decode` so that we can remove type assertion
tokenAddress: (decodedAssetData as any).tokenContract,
};
},
/**
* Encodes an ERC721 token address into a hex encoded assetData string, usable in the makerAssetData or
* takerAssetData fields in a 0x order.
* @param tokenAddress The ERC721 token address to encode
* @param tokenId The ERC721 tokenId to encode
* @return The hex encoded assetData string
*/
encodeERC721AssetData(tokenAddress: string, tokenId: BigNumber): string {
const abiEncoder = new AbiEncoder.Method(constants.ERC721_METHOD_ABI);
const args = [tokenAddress, tokenId];
const assetData = abiEncoder.encode(args, encodingRules);
return assetData;
},
/**
* Decodes an ERC721 assetData hex string into its corresponding ERC721 tokenAddress, tokenId & assetProxyId
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded tokenAddress, tokenId & assetProxyId
*/
decodeERC721AssetData(assetData: string): ERC721AssetData {
assetDataUtils.assertIsERC721AssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
const abiEncoder = new AbiEncoder.Method(constants.ERC721_METHOD_ABI);
const decodedAssetData = abiEncoder.decode(assetData, decodingRules);
return {
assetProxyId,
// TODO(abandeali1): fix return types for `AbiEncoder.Method.decode` so that we can remove type assertion
tokenAddress: (decodedAssetData as any).tokenContract,
tokenId: (decodedAssetData as any).tokenId,
};
},
/**
* Encodes a set of ERC1155 assets into an assetData string, usable in the makerAssetData or
* takerAssetData fields of a 0x order.
* @param tokenAddress The token address of the ERC1155 contract
* @param tokenIds The Id's of the ERC1155 tokens to transfer
* @param tokenValues The values of each respective token Id to transfer
* @param callbackData The data forwarded to a receiver, if receiver is a contract.
* @return The hex encoded assetData string
*/
encodeERC1155AssetData(
tokenAddress: string,
tokenIds: BigNumber[],
tokenValues: BigNumber[],
callbackData: string,
): string {
const abiEncoder = AbiEncoder.createMethod('ERC1155Assets', constants.ERC1155_METHOD_ABI.inputs);
const args = [tokenAddress, tokenIds, tokenValues, callbackData];
const assetData = abiEncoder.encode(args, encodingRules);
return assetData;
},
/**
* Decodes an ERC1155 assetData hex string into its corresponding ERC1155 components.
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded tokenAddress, tokenIds, tokenValues, callbackData & assetProxyId
*/
decodeERC1155AssetData(assetData: string): ERC1155AssetData {
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.ERC1155) {
throw new Error(`Invalid assetProxyId. Expected '${AssetProxyId.ERC1155}', got '${assetProxyId}'`);
}
const abiEncoder = AbiEncoder.createMethod('ERC1155Assets', constants.ERC1155_METHOD_ABI.inputs);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedAssetData = abiEncoder.decode(assetData, decodingRules) as ERC1155AssetDataNoProxyId;
return {
assetProxyId,
tokenAddress: decodedAssetData.tokenAddress,
tokenIds: decodedAssetData.tokenIds,
tokenValues: decodedAssetData.tokenValues,
callbackData: decodedAssetData.callbackData,
};
},
/**
* Encodes assetData for multiple AssetProxies into a single hex encoded assetData string, usable in the makerAssetData or
* takerAssetData fields in a 0x order.
* @param amounts Amounts of each asset that correspond to a single unit within an order.
* @param nestedAssetData assetData strings that correspond to a valid assetProxyId.
* @return The hex encoded assetData string
*/
encodeMultiAssetData(amounts: BigNumber[], nestedAssetData: string[]): string {
if (amounts.length !== nestedAssetData.length) {
throw new Error(
`Invalid MultiAsset arguments. Expected length of 'amounts' (${
amounts.length
}) to equal length of 'nestedAssetData' (${nestedAssetData.length})`,
);
}
_.forEach(nestedAssetData, assetDataElement => assetDataUtils.validateAssetDataOrThrow(assetDataElement));
const abiEncoder = new AbiEncoder.Method(constants.MULTI_ASSET_METHOD_ABI);
const args = [amounts, nestedAssetData];
const assetData = abiEncoder.encode(args, encodingRules);
return assetData;
},
/**
* Decodes a MultiAsset assetData hex string into its corresponding amounts and nestedAssetData
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded amounts and nestedAssetData
*/
decodeMultiAssetData(assetData: string): MultiAssetData {
assetDataUtils.assertIsMultiAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
const abiEncoder = new AbiEncoder.Method(constants.MULTI_ASSET_METHOD_ABI);
const decodedAssetData = abiEncoder.decode(assetData, decodingRules);
// TODO(abandeali1): fix return types for `AbiEncoder.Method.decode` so that we can remove type assertion
const amounts = (decodedAssetData as any).amounts;
const nestedAssetData = (decodedAssetData as any).nestedAssetData;
if (amounts.length !== nestedAssetData.length) {
throw new Error(
`Invalid MultiAsset assetData. Expected length of 'amounts' (${
amounts.length
}) to equal length of 'nestedAssetData' (${nestedAssetData.length})`,
);
}
return {
assetProxyId,
amounts,
nestedAssetData,
};
},
/**
* Decodes a MultiAsset assetData hex string into its corresponding amounts and decoded nestedAssetData elements (all nested elements are flattened)
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded amounts and nestedAssetData
*/
decodeMultiAssetDataRecursively(assetData: string): MultiAssetDataWithRecursiveDecoding {
const decodedAssetData = assetDataUtils.decodeMultiAssetData(assetData);
const amounts: any[] = [];
const decodedNestedAssetData = _.map(
decodedAssetData.nestedAssetData as string[],
(nestedAssetDataElement, index) => {
const decodedNestedAssetDataElement = assetDataUtils.decodeAssetDataOrThrow(nestedAssetDataElement);
if (decodedNestedAssetDataElement.assetProxyId === AssetProxyId.MultiAsset) {
const recursivelyDecodedAssetData = assetDataUtils.decodeMultiAssetDataRecursively(
nestedAssetDataElement,
);
amounts.push(
_.map(recursivelyDecodedAssetData.amounts, amountElement =>
amountElement.times(decodedAssetData.amounts[index]),
),
);
return recursivelyDecodedAssetData.nestedAssetData;
} else {
amounts.push(decodedAssetData.amounts[index]);
return decodedNestedAssetDataElement as SingleAssetData;
}
},
);
const flattenedAmounts = _.flattenDeep(amounts);
const flattenedDecodedNestedAssetData = _.flattenDeep(decodedNestedAssetData);
return {
assetProxyId: decodedAssetData.assetProxyId,
amounts: flattenedAmounts,
// tslint:disable-next-line:no-unnecessary-type-assertion
nestedAssetData: flattenedDecodedNestedAssetData as SingleAssetData[],
};
},
/**
* Encodes StaticCallProxy data into an assetData hex string
* @param callTarget Address of contract to call from StaticCallProxy
* @param staticCallData The function data that will be called on the callTarget contract
* @param callResultHash The keccak256 hash of the ABI encoded expected output of the static call
* @return The hex encoded assetData string
*/
encodeStaticCallAssetData(callTarget: string, staticCallData: string, callResultHash: string): string {
const abiEncoder = AbiEncoder.createMethod('StaticCall', constants.STATIC_CALL_METHOD_ABI.inputs);
const args = [callTarget, staticCallData, callResultHash];
const assetData = abiEncoder.encode(args, encodingRules);
return assetData;
},
/**
* Decoded StaticCall assetData into its corresponding callTarget, staticCallData, and expected callResultHash
* @param assetData Hex encoded assetData string to decode
* @return An object containing the decoded callTarget, staticCallData, and expected callResultHash
*/
decodeStaticCallAssetData(assetData: string): StaticCallAssetData {
const abiEncoder = AbiEncoder.createMethod('StaticCall', constants.STATIC_CALL_METHOD_ABI.inputs);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
const decodedAssetData = abiEncoder.decode(assetData, decodingRules) as any;
return {
assetProxyId,
callTarget: decodedAssetData.callTarget,
callResultHash: decodedAssetData.callResultHash,
staticCallData: decodedAssetData.staticCallData,
};
},
/**
* Decode and return the assetProxyId from the assetData
* @param assetData Hex encoded assetData string to decode
* @return The assetProxyId
*/
decodeAssetProxyId(assetData: string): AssetProxyId {
if (assetData.length < constants.SELECTOR_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode assetData. Expected length of encoded data to be at least 10. Got ${
assetData.length
}`,
);
}
const assetProxyId = assetData.slice(0, constants.SELECTOR_CHAR_LENGTH_WITH_PREFIX);
if (
assetProxyId !== AssetProxyId.ERC20 &&
assetProxyId !== AssetProxyId.ERC721 &&
assetProxyId !== AssetProxyId.ERC1155 &&
assetProxyId !== AssetProxyId.StaticCall &&
assetProxyId !== AssetProxyId.MultiAsset
) {
throw new Error(`Invalid assetProxyId: ${assetProxyId}`);
}
return assetProxyId;
},
/**
* Checks if the decoded asset data is valid ERC20 data
* @param decodedAssetData The decoded asset data to check
*/
isERC20AssetData(decodedAssetData: SingleAssetData | MultiAssetData): decodedAssetData is ERC20AssetData {
return decodedAssetData.assetProxyId === AssetProxyId.ERC20;
},
/**
* Checks if the decoded asset data is valid ERC721 data
* @param decodedAssetData The decoded asset data to check
*/
isERC721AssetData(decodedAssetData: SingleAssetData | MultiAssetData): decodedAssetData is ERC721AssetData {
return decodedAssetData.assetProxyId === AssetProxyId.ERC721;
},
/**
* Checks if the decoded asset data is valid ERC1155 data
* @param decodedAssetData The decoded asset data to check
*/
isERC1155AssetData(decodedAssetData: SingleAssetData | MultiAssetData): decodedAssetData is ERC1155AssetData {
return decodedAssetData.assetProxyId === AssetProxyId.ERC1155;
},
/**
* Checks if the decoded asset data is valid MultiAsset data
* @param decodedAssetData The decoded asset data to check
*/
isMultiAssetData(decodedAssetData: SingleAssetData | MultiAssetData): decodedAssetData is MultiAssetData {
return decodedAssetData.assetProxyId === AssetProxyId.MultiAsset;
},
/**
* Checks if the decoded asset data is valid StaticCall data
* @param decodedAssetData The decoded asset data to check
*/
isStaticCallAssetData(decodedAssetData: SingleAssetData | MultiAssetData): decodedAssetData is StaticCallAssetData {
return decodedAssetData.assetProxyId === AssetProxyId.StaticCall;
},
/**
* Throws if the length or assetProxyId are invalid for the ERC20Proxy.
* @param assetData Hex encoded assetData string
*/
assertIsERC20AssetData(assetData: string): void {
if (assetData.length < constants.ERC20_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode ERC20 Proxy Data. Expected length of encoded data to be at least ${
constants.ERC20_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX
}. Got ${assetData.length}`,
);
}
assetDataUtils.assertWordAlignedAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.ERC20) {
throw new Error(
`Could not decode ERC20 assetData. Expected assetProxyId to be ERC20 (${
AssetProxyId.ERC20
}), but got ${assetProxyId}`,
);
}
},
/**
* Throws if the length or assetProxyId are invalid for the ERC721Proxy.
* @param assetData Hex encoded assetData string
*/
assertIsERC721AssetData(assetData: string): void {
if (assetData.length < constants.ERC721_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode ERC721 assetData. Expected length of encoded data to be at least ${
constants.ERC721_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX
}. Got ${assetData.length}`,
);
}
assetDataUtils.assertWordAlignedAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.ERC721) {
throw new Error(
`Could not decode ERC721 assetData. Expected assetProxyId to be ERC721 (${
AssetProxyId.ERC721
}), but got ${assetProxyId}`,
);
}
},
/**
* Throws if the assetData is not ERC1155.
* @param assetData Hex encoded assetData string
*/
assertIsERC1155AssetData(assetData: string): void {
if (assetData.length < constants.ERC1155_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode ERC1155 Proxy Data. Expected length of encoded data to be at least ${
constants.ERC1155_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX
}. Got ${assetData.length}`,
);
}
assetDataUtils.assertWordAlignedAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.ERC1155) {
throw new Error(
`Could not decode ERC1155 assetData. Expected assetProxyId to be ERC1155 (${
AssetProxyId.ERC1155
}), but got ${assetProxyId}`,
);
}
},
/**
* Throws if the length or assetProxyId are invalid for the MultiAssetProxy.
* @param assetData Hex encoded assetData string
*/
assertIsMultiAssetData(assetData: string): void {
if (assetData.length < constants.MULTI_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode MultiAsset assetData. Expected length of encoded data to be at least ${
constants.MULTI_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX
}. Got ${assetData.length}`,
);
}
assetDataUtils.assertWordAlignedAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.MultiAsset) {
throw new Error(
`Could not decode MultiAsset assetData. Expected assetProxyId to be MultiAsset (${
AssetProxyId.MultiAsset
}), but got ${assetProxyId}`,
);
}
},
/**
* Throws if the assetData is not StaticCallData.
* @param assetData Hex encoded assetData string
*/
assertIsStaticCallAssetData(assetData: string): void {
if (assetData.length < constants.STATIC_CALL_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX) {
throw new Error(
`Could not decode StaticCall Proxy Data. Expected length of encoded data to be at least ${
constants.STATIC_CALL_ASSET_DATA_MIN_CHAR_LENGTH_WITH_PREFIX
}. Got ${assetData.length}`,
);
}
assetDataUtils.assertWordAlignedAssetData(assetData);
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
if (assetProxyId !== AssetProxyId.StaticCall) {
throw new Error(
`Could not decode StaticCall assetData. Expected assetProxyId to be StaticCall (${
AssetProxyId.StaticCall
}), but got ${assetProxyId}`,
);
}
},
/**
* Throws if the assetData is not padded to 32 bytes.
* @param assetData Hex encoded assetData string
*/
assertWordAlignedAssetData(assetData: string): void {
const charsIn32Bytes = 64;
if ((assetData.length - constants.SELECTOR_CHAR_LENGTH_WITH_PREFIX) % charsIn32Bytes !== 0) {
throw new Error(
`assetData must be word aligned. ${(assetData.length - 2) / 2} is not a valid byte length.`,
);
}
},
/**
* Throws if the length or assetProxyId are invalid for the corresponding AssetProxy.
* @param assetData Hex encoded assetData string
*/
validateAssetDataOrThrow(assetData: string): void {
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
switch (assetProxyId) {
case AssetProxyId.ERC20:
assetDataUtils.assertIsERC20AssetData(assetData);
break;
case AssetProxyId.ERC721:
assetDataUtils.assertIsERC721AssetData(assetData);
break;
case AssetProxyId.ERC1155:
assetDataUtils.assertIsERC1155AssetData(assetData);
break;
case AssetProxyId.MultiAsset:
assetDataUtils.assertIsMultiAssetData(assetData);
break;
case AssetProxyId.StaticCall:
assetDataUtils.assertIsStaticCallAssetData(assetData);
break;
default:
throw new Error(`Unrecognized asset proxy id: ${assetProxyId}`);
}
},
/**
* Decode any assetData into its corresponding assetData object
* @param assetData Hex encoded assetData string to decode
* @return Either a ERC20, ERC721, ERC1155, or MultiAsset assetData object
*/
decodeAssetDataOrThrow(assetData: string): SingleAssetData | MultiAssetData {
const assetProxyId = assetDataUtils.decodeAssetProxyId(assetData);
switch (assetProxyId) {
case AssetProxyId.ERC20:
const erc20AssetData = assetDataUtils.decodeERC20AssetData(assetData);
return erc20AssetData;
case AssetProxyId.ERC721:
const erc721AssetData = assetDataUtils.decodeERC721AssetData(assetData);
return erc721AssetData;
case AssetProxyId.ERC1155:
const erc1155AssetData = assetDataUtils.decodeERC1155AssetData(assetData);
return erc1155AssetData;
case AssetProxyId.MultiAsset:
const multiAssetData = assetDataUtils.decodeMultiAssetData(assetData);
return multiAssetData;
case AssetProxyId.StaticCall:
const staticCallData = assetDataUtils.decodeStaticCallAssetData(assetData);
return staticCallData;
default:
throw new Error(`Unrecognized asset proxy id: ${assetProxyId}`);
}
},
};
// tslint:disable:max-file-line-count

80
packages/order-utils/src/decode_asset_data.ts Normal file
View File

@ -0,0 +1,80 @@
import { IAssetDataContract } from '@0x/contract-wrappers';
import { AssetData, AssetProxyId } from '@0x/types';
import { BigNumber, hexUtils, NULL_ADDRESS } from '@0x/utils';
const fakeProvider = { isEIP1193: true } as any;
const assetDataDecoder = new IAssetDataContract(NULL_ADDRESS, fakeProvider);
/**
* Decode any assetData into its corresponding assetData object
* @param assetData Hex encoded assetData string to decode
* @return Either a ERC20, ERC20Bridge, ERC721, ERC1155, StaticCall, or MultiAsset assetData object
*/
export function decodeAssetDataOrThrow(assetData: string): AssetData {
const assetProxyId = hexUtils.slice(assetData, 0, 4); // tslint:disable-line:custom-no-magic-numbers
switch (assetProxyId) {
case AssetProxyId.ERC20: {
const tokenAddress = assetDataDecoder.getABIDecodedTransactionData<string>('ERC20Token', assetData);
return {
assetProxyId,
tokenAddress,
};
}
case AssetProxyId.ERC20Bridge: {
const [tokenAddress, bridgeAddress, bridgeData] = assetDataDecoder.getABIDecodedTransactionData<
[string, string, string]
>('ERC20Bridge', assetData);
return {
assetProxyId,
tokenAddress,
bridgeAddress,
bridgeData,
};
}
case AssetProxyId.ERC721: {
const [tokenAddress, tokenId] = assetDataDecoder.getABIDecodedTransactionData<[string, BigNumber]>(
'ERC721Token',
assetData,
);
return {
assetProxyId,
tokenAddress,
tokenId,
};
}
case AssetProxyId.ERC1155: {
const [tokenAddress, tokenIds, tokenValues] = assetDataDecoder.getABIDecodedTransactionData<
[string, BigNumber[], BigNumber[]]
>('ERC1155Assets', assetData);
return {
assetProxyId,
tokenAddress,
tokenIds,
tokenValues,
};
}
case AssetProxyId.MultiAsset: {
const [amounts, nestedAssetData] = assetDataDecoder.getABIDecodedTransactionData<[BigNumber[], string[]]>(
'MultiAsset',
assetData,
);
return {
assetProxyId,
amounts,
nestedAssetData,
};
}
case AssetProxyId.StaticCall:
const [callTarget, staticCallData, callResultHash] = assetDataDecoder.getABIDecodedTransactionData<
[string, string, string]
>('StaticCall', assetData);
return {
assetProxyId,
callTarget,
staticCallData,
callResultHash,
};
default:
throw new Error(`Unhandled asset proxy ID: ${assetProxyId}`);
}
}

5
packages/order-utils/src/index.ts
View File

@ -1,11 +1,11 @@
export { signatureUtils } from './signature_utils'; export { signatureUtils } from './signature_utils';
export { generatePseudoRandomSalt } from './salt'; export { generatePseudoRandomSalt } from './salt';
export { assetDataUtils } from './asset_data_utils';
export { marketUtils } from './market_utils'; export { marketUtils } from './market_utils';
export { rateUtils } from './rate_utils'; export { rateUtils } from './rate_utils';
export { sortingUtils } from './sorting_utils'; export { sortingUtils } from './sorting_utils';
export { orderCalculationUtils } from './order_calculation_utils'; export { orderCalculationUtils } from './order_calculation_utils';
export { orderHashUtils } from './order_hash_utils'; export { orderHashUtils } from './order_hash_utils';
export { decodeAssetDataOrThrow } from './decode_asset_data';
export { eip712Utils } from './eip712_utils'; export { eip712Utils } from './eip712_utils';
@ -29,14 +29,15 @@ export {
SignedOrder, SignedOrder,
Order, Order,
ECSignature, ECSignature,
AssetData,
SingleAssetData, SingleAssetData,
ERC20AssetData, ERC20AssetData,
ERC20BridgeAssetData,
ERC721AssetData, ERC721AssetData,
ERC1155AssetData, ERC1155AssetData,
MultiAssetData, MultiAssetData,
StaticCallAssetData, StaticCallAssetData,
MultiAssetDataWithRecursiveDecoding, MultiAssetDataWithRecursiveDecoding,
AssetProxyId,
SignatureType, SignatureType,
EIP712Parameter, EIP712Parameter,
EIP712TypedData, EIP712TypedData,

178
packages/order-utils/test/asset_data_utils_test.ts
View File

@ -1,178 +0,0 @@
import * as chai from 'chai';
import { AssetProxyId, ERC1155AssetData, ERC20AssetData, ERC721AssetData } from '@0x/types';
import { BigNumber } from '@0x/utils';
import { assetDataUtils } from '../src/asset_data_utils';
import { chaiSetup } from './utils/chai_setup';
chaiSetup.configure();
const expect = chai.expect;
const KNOWN_ERC20_ENCODING = {
address: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
assetData: '0xf47261b00000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48',
};
const KNOWN_ERC721_ENCODING = {
address: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
tokenId: new BigNumber(1),
assetData:
'0x025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001',
};
const KNOWN_ERC1155_ENCODING = {
tokenAddress: '0x1dc4c1cefef38a777b15aa20260a54e584b16c48',
tokenIds: [new BigNumber(100), new BigNumber(1001), new BigNumber(10001)],
tokenValues: [new BigNumber(200), new BigNumber(2001), new BigNumber(20001)],
callbackData:
'0x025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001',
assetData:
'0xa7cb5fb70000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000003e90000000000000000000000000000000000000000000000000000000000002711000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000007d10000000000000000000000000000000000000000000000000000000000004e210000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000',
};
const KNOWN_MULTI_ASSET_ENCODING = {
amounts: [new BigNumber(70), new BigNumber(1), new BigNumber(18)],
nestedAssetData: [
KNOWN_ERC20_ENCODING.assetData,
KNOWN_ERC721_ENCODING.assetData,
KNOWN_ERC1155_ENCODING.assetData,
],
assetData:
'0x94cfcdd7000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000046000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000024f47261b00000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c48000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000204a7cb5fb70000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c480000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000003e90000000000000000000000000000000000000000000000000000000000002711000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000007d10000000000000000000000000000000000000000000000000000000000004e210000000000000000000000000000000000000000000000000000000000000044025717920000000000000000000000001dc4c1cefef38a777b15aa20260a54e584b16c4800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
};
describe('assetDataUtils', () => {
it('should encode ERC20', () => {
const assetData = assetDataUtils.encodeERC20AssetData(KNOWN_ERC20_ENCODING.address);
expect(assetData).to.equal(KNOWN_ERC20_ENCODING.assetData);
});
it('should decode ERC20', () => {
const decodedAssetData = assetDataUtils.decodeERC20AssetData(KNOWN_ERC20_ENCODING.assetData);
expect(decodedAssetData.tokenAddress).to.equal(KNOWN_ERC20_ENCODING.address);
expect(decodedAssetData.assetProxyId).to.equal(AssetProxyId.ERC20);
});
it('should encode ERC721', () => {
const assetData = assetDataUtils.encodeERC721AssetData(
KNOWN_ERC721_ENCODING.address,
KNOWN_ERC721_ENCODING.tokenId,
);
expect(assetData).to.equal(KNOWN_ERC721_ENCODING.assetData);
});
it('should decode ERC721', () => {
const decodedAssetData = assetDataUtils.decodeERC721AssetData(KNOWN_ERC721_ENCODING.assetData);
expect(decodedAssetData.tokenAddress).to.equal(KNOWN_ERC721_ENCODING.address);
expect(decodedAssetData.assetProxyId).to.equal(AssetProxyId.ERC721);
expect(decodedAssetData.tokenId).to.be.bignumber.equal(KNOWN_ERC721_ENCODING.tokenId);
});
it('should encode ERC1155', () => {
const assetData = assetDataUtils.encodeERC1155AssetData(
KNOWN_ERC1155_ENCODING.tokenAddress,
KNOWN_ERC1155_ENCODING.tokenIds,
KNOWN_ERC1155_ENCODING.tokenValues,
KNOWN_ERC1155_ENCODING.callbackData,
);
expect(assetData).to.equal(KNOWN_ERC1155_ENCODING.assetData);
});
it('should decode ERC1155', () => {
const decodedAssetData = assetDataUtils.decodeERC1155AssetData(KNOWN_ERC1155_ENCODING.assetData);
expect(decodedAssetData.assetProxyId).to.be.equal(AssetProxyId.ERC1155);
expect(decodedAssetData.tokenAddress).to.be.equal(KNOWN_ERC1155_ENCODING.tokenAddress);
expect(decodedAssetData.tokenValues).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenValues);
expect(decodedAssetData.tokenIds).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenIds);
expect(decodedAssetData.callbackData).to.be.equal(KNOWN_ERC1155_ENCODING.callbackData);
});
it('should encode ERC20, ERC721 and ERC1155 multiAssetData', () => {
const assetData = assetDataUtils.encodeMultiAssetData(
KNOWN_MULTI_ASSET_ENCODING.amounts,
KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
);
expect(assetData).to.equal(KNOWN_MULTI_ASSET_ENCODING.assetData);
});
it('should decode ERC20, ERC721 and ERC1155 multiAssetData', () => {
const decodedAssetData = assetDataUtils.decodeMultiAssetData(KNOWN_MULTI_ASSET_ENCODING.assetData);
expect(decodedAssetData.assetProxyId).to.equal(AssetProxyId.MultiAsset);
expect(decodedAssetData.amounts).to.deep.equal(KNOWN_MULTI_ASSET_ENCODING.amounts);
expect(decodedAssetData.nestedAssetData).to.deep.equal(KNOWN_MULTI_ASSET_ENCODING.nestedAssetData);
});
it('should recursively decode ERC20 and ERC721 multiAssetData', () => {
const decodedAssetData = assetDataUtils.decodeMultiAssetDataRecursively(KNOWN_MULTI_ASSET_ENCODING.assetData);
expect(decodedAssetData.assetProxyId).to.equal(AssetProxyId.MultiAsset);
expect(decodedAssetData.amounts).to.deep.equal(KNOWN_MULTI_ASSET_ENCODING.amounts);
expect(decodedAssetData.nestedAssetData.length).to.equal(3);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc20AssetData = decodedAssetData.nestedAssetData[0] as ERC20AssetData;
expect(decodedErc20AssetData.tokenAddress).to.equal(KNOWN_ERC20_ENCODING.address);
expect(decodedErc20AssetData.assetProxyId).to.equal(AssetProxyId.ERC20);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc721AssetData = decodedAssetData.nestedAssetData[1] as ERC721AssetData;
expect(decodedErc721AssetData.tokenAddress).to.equal(KNOWN_ERC721_ENCODING.address);
expect(decodedErc721AssetData.assetProxyId).to.equal(AssetProxyId.ERC721);
expect(decodedErc721AssetData.tokenId).to.be.bignumber.equal(KNOWN_ERC721_ENCODING.tokenId);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc1155AssetData = decodedAssetData.nestedAssetData[2] as ERC1155AssetData;
expect(decodedErc1155AssetData.tokenAddress).to.be.equal(KNOWN_ERC1155_ENCODING.tokenAddress);
expect(decodedErc1155AssetData.tokenValues).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenValues);
expect(decodedErc1155AssetData.tokenIds).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenIds);
expect(decodedErc1155AssetData.callbackData).to.be.equal(KNOWN_ERC1155_ENCODING.callbackData);
});
it('should recursively decode nested assetData within multiAssetData', () => {
// setup test parameters
const erc20Amount = new BigNumber(1);
const erc721Amount = new BigNumber(1);
const erc1155Amount = new BigNumber(15);
const nestedAssetsAmount = new BigNumber(2);
const amounts = [erc20Amount, erc721Amount, erc1155Amount, nestedAssetsAmount];
const nestedAssetData = [
KNOWN_ERC20_ENCODING.assetData,
KNOWN_ERC721_ENCODING.assetData,
KNOWN_ERC1155_ENCODING.assetData,
KNOWN_MULTI_ASSET_ENCODING.assetData,
];
const assetData = assetDataUtils.encodeMultiAssetData(amounts, nestedAssetData);
// execute test
const decodedAssetData = assetDataUtils.decodeMultiAssetDataRecursively(assetData);
// validate asset data
expect(decodedAssetData.assetProxyId).to.equal(AssetProxyId.MultiAsset);
const expectedAmounts = [
erc20Amount,
erc721Amount,
erc1155Amount,
KNOWN_MULTI_ASSET_ENCODING.amounts[0].times(nestedAssetsAmount),
KNOWN_MULTI_ASSET_ENCODING.amounts[1].times(nestedAssetsAmount),
KNOWN_MULTI_ASSET_ENCODING.amounts[2].times(nestedAssetsAmount),
];
expect(decodedAssetData.amounts).to.deep.equal(expectedAmounts);
const expectedNestedAssetDataLength = 6;
expect(decodedAssetData.nestedAssetData.length).to.be.equal(expectedNestedAssetDataLength);
// validate nested asset data (outer)
let nestedAssetDataIndex = 0;
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc20AssetData1 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC20AssetData;
expect(decodedErc20AssetData1.tokenAddress).to.equal(KNOWN_ERC20_ENCODING.address);
expect(decodedErc20AssetData1.assetProxyId).to.equal(AssetProxyId.ERC20);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc721AssetData1 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC721AssetData;
expect(decodedErc721AssetData1.tokenAddress).to.equal(KNOWN_ERC721_ENCODING.address);
expect(decodedErc721AssetData1.assetProxyId).to.equal(AssetProxyId.ERC721);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc1155AssetData1 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC1155AssetData;
expect(decodedErc1155AssetData1.tokenAddress).to.be.equal(KNOWN_ERC1155_ENCODING.tokenAddress);
expect(decodedErc1155AssetData1.tokenValues).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenValues);
expect(decodedErc1155AssetData1.tokenIds).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenIds);
expect(decodedErc1155AssetData1.callbackData).to.be.equal(KNOWN_ERC1155_ENCODING.callbackData);
// validate nested asset data (inner)
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc20AssetData2 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC20AssetData;
expect(decodedErc20AssetData2.tokenAddress).to.equal(KNOWN_ERC20_ENCODING.address);
expect(decodedErc20AssetData2.assetProxyId).to.equal(AssetProxyId.ERC20);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc721AssetData2 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC721AssetData;
expect(decodedErc721AssetData2.tokenAddress).to.equal(KNOWN_ERC721_ENCODING.address);
expect(decodedErc721AssetData2.assetProxyId).to.equal(AssetProxyId.ERC721);
// tslint:disable-next-line:no-unnecessary-type-assertion
const decodedErc1155AssetData2 = decodedAssetData.nestedAssetData[nestedAssetDataIndex++] as ERC1155AssetData;
expect(decodedErc1155AssetData2.tokenAddress).to.be.equal(KNOWN_ERC1155_ENCODING.tokenAddress);
expect(decodedErc1155AssetData2.tokenValues).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenValues);
expect(decodedErc1155AssetData2.tokenIds).to.be.deep.equal(KNOWN_ERC1155_ENCODING.tokenIds);
expect(decodedErc1155AssetData2.callbackData).to.be.equal(KNOWN_ERC1155_ENCODING.callbackData);
});
});

9
packages/types/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "3.1.0",
"changes": [
{
"note": "Add `ERC20BridgeAssetData`",
"pr": 2373
}
]
},
{ {
"version": "3.0.0", "version": "3.0.0",
"changes": [ "changes": [

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

@ -173,6 +173,13 @@ export interface ERC20AssetData {
tokenAddress: string; tokenAddress: string;
} }
export interface ERC20BridgeAssetData {
assetProxyId: string;
tokenAddress: string;
bridgeAddress: string;
bridgeData: string;
}
export interface ERC721AssetData { export interface ERC721AssetData {
assetProxyId: string; assetProxyId: string;
tokenAddress: string; tokenAddress: string;
@ -201,7 +208,12 @@ export interface ERC1155AssetDataNoProxyId {
callbackData: string; callbackData: string;
} }
export type SingleAssetData = ERC20AssetData | ERC721AssetData | ERC1155AssetData | StaticCallAssetData; export type SingleAssetData =
| ERC20AssetData
| ERC20BridgeAssetData
| ERC721AssetData
| ERC1155AssetData
| StaticCallAssetData;
export interface MultiAssetData { export interface MultiAssetData {
assetProxyId: string; assetProxyId: string;

9
packages/utils/CHANGELOG.json
View File

@ -1,4 +1,13 @@
[ [
{
"version": "5.1.0",
"changes": [
{
"note": "Added hex_utils",
"pr": 2373
}
]
},
{ {
"version": "5.0.0", "version": "5.0.0",
"changes": [ "changes": [

53
contracts/test-utils/src/hex_utils.ts → packages/utils/src/hex_utils.ts
View File

@ -1,46 +1,59 @@
import { BigNumber } from '@0x/utils';
import * as crypto from 'crypto'; import * as crypto from 'crypto';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import { constants } from './constants'; import { BigNumber } from './index';
import { Numberish } from './types'; import { Numberish } from './types';
const { WORD_LENGTH } = constants; // tslint:disable:custom-no-magic-numbers
const WORD_LENGTH = 32;
const WORD_CEIL = new BigNumber(2).pow(WORD_LENGTH * 8); const WORD_CEIL = new BigNumber(2).pow(WORD_LENGTH * 8);
export const hexUtils = {
concat,
random,
leftPad,
rightPad,
invert,
slice,
hash,
size,
toHex,
};
/** /**
* Concatenate all arguments as a hex string. * Concatenate all arguments as a hex string.
*/ */
export function hexConcat(...args: Array<string | number | Buffer>): string { function concat(...args: Array<string | number | Buffer>): string {
return ethUtil.bufferToHex(Buffer.concat(args.map(h => ethUtil.toBuffer(h)))); return ethUtil.bufferToHex(Buffer.concat(args.map(h => ethUtil.toBuffer(h))));
} }
/** /**
* Generate a random hex string. * Generate a random hex string.
*/ */
export function hexRandom(size: number = WORD_LENGTH): string { function random(_size: number = WORD_LENGTH): string {
return ethUtil.bufferToHex(crypto.randomBytes(size)); return ethUtil.bufferToHex(crypto.randomBytes(_size));
} }
/** /**
* Left-pad a hex number to a number of bytes. * Left-pad a hex number to a number of bytes.
*/ */
export function hexLeftPad(n: Numberish, size: number = WORD_LENGTH): string { function leftPad(n: Numberish, _size: number = WORD_LENGTH): string {
return ethUtil.bufferToHex(ethUtil.setLengthLeft(toHex(n), size)); return ethUtil.bufferToHex(ethUtil.setLengthLeft(hexUtils.toHex(n), _size));
} }
/** /**
* Right-pad a hex number to a number of bytes. * Right-pad a hex number to a number of bytes.
*/ */
export function hexRightPad(n: Numberish, size: number = WORD_LENGTH): string { function rightPad(n: Numberish, _size: number = WORD_LENGTH): string {
return ethUtil.bufferToHex(ethUtil.setLengthRight(toHex(n), size)); return ethUtil.bufferToHex(ethUtil.setLengthRight(hexUtils.toHex(n), _size));
} }
/** /**
* Inverts a hex word. * Inverts a hex word.
*/ */
export function hexInvert(n: Numberish, size: number = WORD_LENGTH): string { function invert(n: Numberish, _size: number = WORD_LENGTH): string {
const buf = ethUtil.setLengthLeft(toHex(n), size); const buf = ethUtil.setLengthLeft(hexUtils.toHex(n), _size);
// tslint:disable-next-line: no-bitwise // tslint:disable-next-line: no-bitwise
return ethUtil.bufferToHex(Buffer.from(buf.map(b => ~b))); return ethUtil.bufferToHex(Buffer.from(buf.map(b => ~b)));
} }
@ -48,8 +61,8 @@ export function hexInvert(n: Numberish, size: number = WORD_LENGTH): string {
/** /**
* Slices a hex number. * Slices a hex number.
*/ */
export function hexSlice(n: Numberish, start: number, end?: number): string { function slice(n: Numberish, start: number, end?: number): string {
const hex = toHex(n).substr(2); const hex = hexUtils.toHex(n).substr(2);
const sliceStart = start >= 0 ? start * 2 : Math.max(0, hex.length + start * 2); const sliceStart = start >= 0 ? start * 2 : Math.max(0, hex.length + start * 2);
let sliceEnd = hex.length; let sliceEnd = hex.length;
if (end !== undefined) { if (end !== undefined) {
@ -61,14 +74,14 @@ export function hexSlice(n: Numberish, start: number, end?: number): string {
/** /**
* Get the keccak hash of some data. * Get the keccak hash of some data.
*/ */
export function hexHash(n: Numberish): string { function hash(n: Numberish): string {
return ethUtil.bufferToHex(ethUtil.sha3(ethUtil.toBuffer(toHex(n)))); return ethUtil.bufferToHex(ethUtil.sha3(ethUtil.toBuffer(hexUtils.toHex(n))));
} }
/** /**
* Get the length, in bytes, of a hex string. * Get the length, in bytes, of a hex string.
*/ */
export function hexSize(hex: string): number { function size(hex: string): number {
return Math.ceil((hex.length - 2) / 2); return Math.ceil((hex.length - 2) / 2);
} }
@ -76,7 +89,7 @@ export function hexSize(hex: string): number {
* Convert a string, a number, or a BigNumber into a hex string. * Convert a string, a number, or a BigNumber into a hex string.
* Works with negative numbers, as well. * Works with negative numbers, as well.
*/ */
export function toHex(n: Numberish, size: number = WORD_LENGTH): string { function toHex(n: Numberish, _size: number = WORD_LENGTH): string {
if (typeof n === 'string' && /^0x[0-9a-f]+$/i.test(n)) { if (typeof n === 'string' && /^0x[0-9a-f]+$/i.test(n)) {
// Already a hex. // Already a hex.
return n; return n;
@ -86,9 +99,9 @@ export function toHex(n: Numberish, size: number = WORD_LENGTH): string {
// Perform two's-complement. // Perform two's-complement.
// prettier-ignore // prettier-ignore
_n = new BigNumber( _n = new BigNumber(
hexInvert( invert(
toHex(_n.abs()), toHex(_n.abs()),
size, _size,
).substr(2), ).substr(2),
16, 16,
).plus(1).mod(WORD_CEIL); ).plus(1).mod(WORD_CEIL);

1
packages/utils/src/index.ts
View File

@ -12,6 +12,7 @@ export { NULL_BYTES, NULL_ADDRESS } from './constants';
export { errorUtils } from './error_utils'; export { errorUtils } from './error_utils';
export { fetchAsync } from './fetch_async'; export { fetchAsync } from './fetch_async';
export { signTypedDataUtils } from './sign_typed_data_utils'; export { signTypedDataUtils } from './sign_typed_data_utils';
export { hexUtils } from './hex_utils';
export import AbiEncoder = require('./abi_encoder'); export import AbiEncoder = require('./abi_encoder');
export * from './types'; export * from './types';
export { generatePseudoRandom256BitNumber } from './random'; export { generatePseudoRandom256BitNumber } from './random';

3
packages/utils/src/types.ts
View File

@ -1,4 +1,5 @@
import { AbiEncoder } from '.'; import { AbiEncoder } from '.';
import { BigNumber } from './index';
export interface FunctionInfo { export interface FunctionInfo {
functionSignature: string; functionSignature: string;
@ -17,3 +18,5 @@ export interface DecodedCalldata {
functionSignature: string; functionSignature: string;
functionArguments: any; functionArguments: any;
} }
export type Numberish = BigNumber | string | number;

83
yarn.lock
View File

@ -643,7 +643,7 @@
npmlog "^4.1.2" npmlog "^4.1.2"
write-file-atomic "^2.3.0" write-file-atomic "^2.3.0"
"@0x/abi-gen-wrappers@^5.4.0-beta.2", "@0x/abi-gen-wrappers@^5.4.0-beta.3": "@0x/abi-gen-wrappers@^5.4.0-beta.3":
version "5.4.0-beta.3" version "5.4.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/abi-gen-wrappers/-/abi-gen-wrappers-5.4.0-beta.3.tgz#8c2d71ef5695fe2d73359917375cfc99b7ba8112" resolved "https://registry.yarnpkg.com/@0x/abi-gen-wrappers/-/abi-gen-wrappers-5.4.0-beta.3.tgz#8c2d71ef5695fe2d73359917375cfc99b7ba8112"
dependencies: dependencies:
@ -660,7 +660,6 @@
"@0x/assert@2.2.0-beta.2": "@0x/assert@2.2.0-beta.2":
version "2.2.0-beta.2" version "2.2.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/assert/-/assert-2.2.0-beta.2.tgz#de78c0bb2c9eff263df5bbe743fe73f19ca9c3bd" resolved "https://registry.yarnpkg.com/@0x/assert/-/assert-2.2.0-beta.2.tgz#de78c0bb2c9eff263df5bbe743fe73f19ca9c3bd"
integrity sha512-30i5fQ2kqejMkLHMrmqTsZedrJ3DR1KKdO6/CfEtP0wN7eF198yIm1VBHsXGRBWcS+1yCd076qbyj0h2X2Deng==
dependencies: dependencies:
"@0x/json-schemas" "^4.1.0-beta.2" "@0x/json-schemas" "^4.1.0-beta.2"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
@ -671,7 +670,6 @@
"@0x/assert@^2.2.0-beta.2", "@0x/assert@^2.2.0-beta.3": "@0x/assert@^2.2.0-beta.2", "@0x/assert@^2.2.0-beta.3":
version "2.2.0-beta.3" version "2.2.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/assert/-/assert-2.2.0-beta.3.tgz#8fb95c265000532cd8dced44d44d29ca544b2bfc" resolved "https://registry.yarnpkg.com/@0x/assert/-/assert-2.2.0-beta.3.tgz#8fb95c265000532cd8dced44d44d29ca544b2bfc"
integrity sha512-ShENc8QJU4ur/5TkRl3l7J3Yt7WaxHAbuoTRm/djcA0iwYyUVlP5yN9Ab9ua+VLizQQTNw1n+kF1mJWg5lQXuA==
dependencies: dependencies:
"@0x/json-schemas" "^4.1.0-beta.3" "@0x/json-schemas" "^4.1.0-beta.3"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
@ -679,10 +677,9 @@
lodash "^4.17.11" lodash "^4.17.11"
valid-url "^1.0.9" valid-url "^1.0.9"
"@0x/base-contract@^5.5.0-beta.2", "@0x/base-contract@^5.5.0-beta.3", "@0x/base-contract@^5.5.0-beta.4": "@0x/base-contract@^5.5.0-beta.3", "@0x/base-contract@^5.5.0-beta.4":
version "5.5.0-beta.4" version "5.5.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/base-contract/-/base-contract-5.5.0-beta.4.tgz#eb26473e033e1a305a9fa87ab9e26325c9face59" resolved "https://registry.yarnpkg.com/@0x/base-contract/-/base-contract-5.5.0-beta.4.tgz#eb26473e033e1a305a9fa87ab9e26325c9face59"
integrity sha512-6OC3Rg2ESoi1k4wABLt67aMGxqdb6FraeEHdAGb07VuPElpyH9jT8dl2aJFAI8tVcnrUQTXeDYJjuK7rimNReg==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.3" "@0x/assert" "^2.2.0-beta.3"
"@0x/json-schemas" "^4.1.0-beta.3" "@0x/json-schemas" "^4.1.0-beta.3"
@ -696,40 +693,37 @@
js-sha3 "^0.7.0" js-sha3 "^0.7.0"
uuid "^3.3.2" uuid "^3.3.2"
"@0x/contract-addresses@3.3.0-beta.3": "@0x/contract-addresses@3.3.0-beta.4":
version "3.3.0-beta.3" version "3.3.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/contract-addresses/-/contract-addresses-3.3.0-beta.3.tgz#0fa8ad47e22aecdb99f9a044ba3c705c4173b61e" resolved "https://registry.yarnpkg.com/@0x/contract-addresses/-/contract-addresses-3.3.0-beta.4.tgz#eec4492702b2e707bcace6ac274f9826761e08a4"
dependencies: dependencies:
lodash "^4.17.11" lodash "^4.17.11"
"@0x/contract-addresses@^3.3.0-beta.3", "@0x/contract-addresses@^3.3.0-beta.4", "@0x/contract-addresses@^3.3.0-beta.5": "@0x/contract-addresses@^3.3.0-beta.4", "@0x/contract-addresses@^3.3.0-beta.5":
version "3.3.0-beta.5" version "3.3.0-beta.5"
resolved "https://registry.yarnpkg.com/@0x/contract-addresses/-/contract-addresses-3.3.0-beta.5.tgz#9d5f80a258f1d103b127159c237f9bcdad182e80" resolved "https://registry.yarnpkg.com/@0x/contract-addresses/-/contract-addresses-3.3.0-beta.5.tgz#9d5f80a258f1d103b127159c237f9bcdad182e80"
integrity sha512-/8de6W1MnVc2zElnCGjK3zgWabBAJZck+zCmNRIMiGtPJIWEW+F3EkAFPfMX6bSZIyrUBlYJIr0xVIWLPU45Aw==
dependencies: dependencies:
lodash "^4.17.11" lodash "^4.17.11"
"@0x/contract-artifacts@^2.3.0-beta.3": "@0x/contract-artifacts@^2.3.0-beta.3":
version "2.3.0-beta.4" version "2.3.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/contract-artifacts/-/contract-artifacts-2.3.0-beta.4.tgz#ca056885be387344aaccf5c69fe80aec248df37d" resolved "https://registry.yarnpkg.com/@0x/contract-artifacts/-/contract-artifacts-2.3.0-beta.4.tgz#ca056885be387344aaccf5c69fe80aec248df37d"
integrity sha512-NpZk3PVE9c2g5kolCcZej2i1l1XlvCFm9FXAny0tCz+/vNb3RhI0m6ecoiS7b1nFEFZ9q6jjsCCb5OEsxMudnw==
"@0x/contract-wrappers@12.2.0-beta.2": "@0x/contract-wrappers@12.2.0-beta.3":
version "12.2.0-beta.2" version "12.2.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/contract-wrappers/-/contract-wrappers-12.2.0-beta.2.tgz#62b3c13e35282df14734d1f6b1a617ed51901a27" resolved "https://registry.yarnpkg.com/@0x/contract-wrappers/-/contract-wrappers-12.2.0-beta.3.tgz#e85a7e42170e98244ab57a1089f8831cf10e3f2d"
dependencies: dependencies:
"@0x/abi-gen-wrappers" "^5.4.0-beta.2" "@0x/abi-gen-wrappers" "^5.4.0-beta.3"
"@0x/base-contract" "^5.5.0-beta.2" "@0x/base-contract" "^5.5.0-beta.3"
"@0x/contract-addresses" "^3.3.0-beta.3" "@0x/contract-addresses" "^3.3.0-beta.4"
"@0x/contract-artifacts" "^2.3.0-beta.3" "@0x/contract-artifacts" "^2.3.0-beta.3"
"@0x/order-utils" "^8.5.0-beta.2" "@0x/order-utils" "^8.5.0-beta.3"
ethers "~4.0.4" ethers "~4.0.4"
http-status-codes "^1.3.2" http-status-codes "^1.3.2"
"@0x/contract-wrappers@^12.2.0-beta.4": "@0x/contract-wrappers@^12.2.0-beta.4":
version "12.2.0-beta.4" version "12.2.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/contract-wrappers/-/contract-wrappers-12.2.0-beta.4.tgz#7a7301dd50c28887879df4d385e80a49e040748d" resolved "https://registry.yarnpkg.com/@0x/contract-wrappers/-/contract-wrappers-12.2.0-beta.4.tgz#7a7301dd50c28887879df4d385e80a49e040748d"
integrity sha512-JVoYG3Rd430fZw9ogBSqeLOaJXkqp9N7g614X5/bzzuG/dSDdwXl48X02m66aGFWcNofx/iMsT4tpOZrJ2bDBg==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.3" "@0x/assert" "^2.2.0-beta.3"
"@0x/base-contract" "^5.5.0-beta.4" "@0x/base-contract" "^5.5.0-beta.4"
@ -741,32 +735,31 @@
ethereum-types "^2.2.0-beta.2" ethereum-types "^2.2.0-beta.2"
ethers "~4.0.4" ethers "~4.0.4"
"@0x/contracts-dev-utils@^0.1.0-beta.2": "@0x/contracts-dev-utils@^0.1.0-beta.3":
version "0.1.0-beta.4" version "0.1.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/contracts-dev-utils/-/contracts-dev-utils-0.1.0-beta.4.tgz#87f51a7ed778b619beb8b32bf08ea6b3e4495d4e" resolved "https://registry.yarnpkg.com/@0x/contracts-dev-utils/-/contracts-dev-utils-0.1.0-beta.4.tgz#87f51a7ed778b619beb8b32bf08ea6b3e4495d4e"
integrity sha512-6fQ13/L8aKKnO/vs2WIg0D7FXz3QpMKBHrTYdzvpwFrOcd6MPavQEj0KCQdT/4aplMvWnWDSVAOqn8i/lJJ8jQ==
dependencies: dependencies:
"@0x/base-contract" "^5.5.0-beta.4" "@0x/base-contract" "^5.5.0-beta.4"
"@0x/contracts-erc20@2.3.0-beta.2": "@0x/contracts-erc20@2.3.0-beta.3":
version "2.3.0-beta.2" version "2.3.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/contracts-erc20/-/contracts-erc20-2.3.0-beta.2.tgz#218239f5594fdbbf8c1ff757a6356ac6fb787421" resolved "https://registry.yarnpkg.com/@0x/contracts-erc20/-/contracts-erc20-2.3.0-beta.3.tgz#744f911d340576a27253b5961d52b09bb8659a98"
dependencies: dependencies:
"@0x/base-contract" "^5.5.0-beta.2" "@0x/base-contract" "^5.5.0-beta.3"
"@0x/types" "^2.5.0-beta.2" "@0x/types" "^2.5.0-beta.2"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
ethereum-types "^2.2.0-beta.2" ethereum-types "^2.2.0-beta.2"
"@0x/coordinator-server@^1.0.3": "@0x/coordinator-server@^1.0.4":
version "1.0.3" version "1.0.4"
resolved "https://registry.yarnpkg.com/@0x/coordinator-server/-/coordinator-server-1.0.3.tgz#736640edc5960bd65674436f96050fd7b4da7ac3" resolved "https://registry.yarnpkg.com/@0x/coordinator-server/-/coordinator-server-1.0.4.tgz#9729ce789fb772a5ae0a8dcdf5928de9e80ac1af"
dependencies: dependencies:
"@0x/assert" "2.2.0-beta.2" "@0x/assert" "2.2.0-beta.2"
"@0x/contract-addresses" "3.3.0-beta.3" "@0x/contract-addresses" "3.3.0-beta.4"
"@0x/contract-wrappers" "12.2.0-beta.2" "@0x/contract-wrappers" "12.2.0-beta.3"
"@0x/contracts-erc20" "2.3.0-beta.2" "@0x/contracts-erc20" "2.3.0-beta.3"
"@0x/json-schemas" "4.1.0-beta.2" "@0x/json-schemas" "4.1.0-beta.2"
"@0x/order-utils" "8.5.0-beta.2" "@0x/order-utils" "8.5.0-beta.3"
"@0x/subproviders" "5.1.0-beta.2" "@0x/subproviders" "5.1.0-beta.2"
"@0x/types" "2.5.0-beta.2" "@0x/types" "2.5.0-beta.2"
"@0x/typescript-typings" "4.4.0-beta.2" "@0x/typescript-typings" "4.4.0-beta.2"
@ -789,7 +782,6 @@
"@0x/json-schemas@4.1.0-beta.2": "@0x/json-schemas@4.1.0-beta.2":
version "4.1.0-beta.2" version "4.1.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/json-schemas/-/json-schemas-4.1.0-beta.2.tgz#79d05d0c91525e2356f783dae5e572dd3624969f" resolved "https://registry.yarnpkg.com/@0x/json-schemas/-/json-schemas-4.1.0-beta.2.tgz#79d05d0c91525e2356f783dae5e572dd3624969f"
integrity sha512-GWLAC4GlcRcn3ct+0wV/ppey+M9bnfnznB1fFcBWS7qmjM0iq36ex3DP48MJroWLWwUiXIWHrAZkp5QCAlc3FA==
dependencies: dependencies:
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
"@types/node" "*" "@types/node" "*"
@ -799,7 +791,6 @@
"@0x/json-schemas@^4.1.0-beta.2", "@0x/json-schemas@^4.1.0-beta.3": "@0x/json-schemas@^4.1.0-beta.2", "@0x/json-schemas@^4.1.0-beta.3":
version "4.1.0-beta.3" version "4.1.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/json-schemas/-/json-schemas-4.1.0-beta.3.tgz#af70a35691108ea162140640bae93a7fc84ca6ee" resolved "https://registry.yarnpkg.com/@0x/json-schemas/-/json-schemas-4.1.0-beta.3.tgz#af70a35691108ea162140640bae93a7fc84ca6ee"
integrity sha512-vcgzSeaOXiUQ4KjqdLTTBHbkWnp4IE7cXbUblRy8Y0XYPQsPywhs9mtjY4lBVNmm1DDpLhreo1mwrvPS3HW5YA==
dependencies: dependencies:
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
"@types/node" "*" "@types/node" "*"
@ -819,15 +810,15 @@
uuid "^3.3.2" uuid "^3.3.2"
websocket "^1.0.29" websocket "^1.0.29"
"@0x/order-utils@8.5.0-beta.2": "@0x/order-utils@8.5.0-beta.3":
version "8.5.0-beta.2" version "8.5.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/order-utils/-/order-utils-8.5.0-beta.2.tgz#ffd3da985e79aab4d0308ab33e399ec51c835ec1" resolved "https://registry.yarnpkg.com/@0x/order-utils/-/order-utils-8.5.0-beta.3.tgz#67bc733cf64cb7cc5653a913e986c5f211b1b7d2"
dependencies: dependencies:
"@0x/abi-gen-wrappers" "^5.4.0-beta.2" "@0x/abi-gen-wrappers" "^5.4.0-beta.3"
"@0x/assert" "^2.2.0-beta.2" "@0x/assert" "^2.2.0-beta.2"
"@0x/contract-addresses" "^3.3.0-beta.3" "@0x/contract-addresses" "^3.3.0-beta.4"
"@0x/contract-artifacts" "^2.3.0-beta.3" "@0x/contract-artifacts" "^2.3.0-beta.3"
"@0x/contracts-dev-utils" "^0.1.0-beta.2" "@0x/contracts-dev-utils" "^0.1.0-beta.3"
"@0x/json-schemas" "^4.1.0-beta.2" "@0x/json-schemas" "^4.1.0-beta.2"
"@0x/types" "^2.5.0-beta.2" "@0x/types" "^2.5.0-beta.2"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
@ -841,10 +832,9 @@
ethers "~4.0.4" ethers "~4.0.4"
lodash "^4.17.11" lodash "^4.17.11"
"@0x/order-utils@^8.5.0-beta.2": "@0x/order-utils@^8.5.0-beta.3":
version "8.5.0-beta.4" version "8.5.0-beta.4"
resolved "https://registry.yarnpkg.com/@0x/order-utils/-/order-utils-8.5.0-beta.4.tgz#900387631008cc9dc9ece125d28450d2beaea462" resolved "https://registry.yarnpkg.com/@0x/order-utils/-/order-utils-8.5.0-beta.4.tgz#900387631008cc9dc9ece125d28450d2beaea462"
integrity sha512-a3vFDAETaPVo/hN5iFr1gxgshfSzAO23NnaUSjeEhs4Ff8eKxuISc6UARFaNzdQeXygDWHMjwlmZ7iegBHe93g==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.3" "@0x/assert" "^2.2.0-beta.3"
"@0x/contract-wrappers" "^12.2.0-beta.4" "@0x/contract-wrappers" "^12.2.0-beta.4"
@ -858,7 +848,6 @@
"@0x/subproviders@5.1.0-beta.2": "@0x/subproviders@5.1.0-beta.2":
version "5.1.0-beta.2" version "5.1.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/subproviders/-/subproviders-5.1.0-beta.2.tgz#020369711330755448397b3b8cecf2868ae7c54c" resolved "https://registry.yarnpkg.com/@0x/subproviders/-/subproviders-5.1.0-beta.2.tgz#020369711330755448397b3b8cecf2868ae7c54c"
integrity sha512-Nk8iSlR95Zo6L1tq2tHLKupX5bCD/NlxQ/KKli4qyAawyxuXQcQbl8flUApJFd+BYY7mghLDwY5u4o8CCR56Nw==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.2" "@0x/assert" "^2.2.0-beta.2"
"@0x/types" "^2.5.0-beta.2" "@0x/types" "^2.5.0-beta.2"
@ -899,7 +888,6 @@
"@0x/types@2.5.0-beta.2": "@0x/types@2.5.0-beta.2":
version "2.5.0-beta.2" version "2.5.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/types/-/types-2.5.0-beta.2.tgz#19d8bda61d5c1b1febc569d30dc8e7bf764d38f9" resolved "https://registry.yarnpkg.com/@0x/types/-/types-2.5.0-beta.2.tgz#19d8bda61d5c1b1febc569d30dc8e7bf764d38f9"
integrity sha512-/7+n09z1dngIN7Kw7L+nleGe0+YXCT4O0VzTihZj6Z2vVHCt+Wo4q1ma9r11vviv07tmqglyw7QbYAfTHIz8Ew==
dependencies: dependencies:
"@types/node" "*" "@types/node" "*"
bignumber.js "~9.0.0" bignumber.js "~9.0.0"
@ -916,7 +904,6 @@
"@0x/types@^2.5.0-beta.2", "@0x/types@^2.5.0-beta.3": "@0x/types@^2.5.0-beta.2", "@0x/types@^2.5.0-beta.3":
version "2.5.0-beta.3" version "2.5.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/types/-/types-2.5.0-beta.3.tgz#e010e9dbf62e37e59177c1d6df8d1acf3a9ea1b4" resolved "https://registry.yarnpkg.com/@0x/types/-/types-2.5.0-beta.3.tgz#e010e9dbf62e37e59177c1d6df8d1acf3a9ea1b4"
integrity sha512-5wJs4/EZGPcU6W5IZ87zuya9vQUPD4DchyP29bXyguGHg9dOxuUOF4WauJZExWlPCS7eivviiUHpZD9DZhni+w==
dependencies: dependencies:
"@types/node" "*" "@types/node" "*"
bignumber.js "~9.0.0" bignumber.js "~9.0.0"
@ -925,7 +912,6 @@
"@0x/typescript-typings@4.4.0-beta.2", "@0x/typescript-typings@^4.4.0-beta.2": "@0x/typescript-typings@4.4.0-beta.2", "@0x/typescript-typings@^4.4.0-beta.2":
version "4.4.0-beta.2" version "4.4.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/typescript-typings/-/typescript-typings-4.4.0-beta.2.tgz#67c621252f162914186b8f684ac5e306206c1cf2" resolved "https://registry.yarnpkg.com/@0x/typescript-typings/-/typescript-typings-4.4.0-beta.2.tgz#67c621252f162914186b8f684ac5e306206c1cf2"
integrity sha512-Fq2nOKvopdLMEjuPiKqomGog06bxAXGjqnodCwv9OKr11V5W1twFTUM3c1TENfHeGvcqf1aMl1hsH3fuVP61jg==
dependencies: dependencies:
"@types/bn.js" "^4.11.0" "@types/bn.js" "^4.11.0"
"@types/react" "*" "@types/react" "*"
@ -946,7 +932,6 @@
"@0x/utils@4.6.0-beta.2": "@0x/utils@4.6.0-beta.2":
version "4.6.0-beta.2" version "4.6.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/utils/-/utils-4.6.0-beta.2.tgz#ffa70f05736a74ac8d7ca5debe01bff7e6d8f073" resolved "https://registry.yarnpkg.com/@0x/utils/-/utils-4.6.0-beta.2.tgz#ffa70f05736a74ac8d7ca5debe01bff7e6d8f073"
integrity sha512-HjewJF4Ibsizh6oWZZxdVxeNc9mGgjdwTCVp/Xj2k9GN6GI8m8EKiowk4Db86wG0/B6y0PDK+985rZ3dtc3MLQ==
dependencies: dependencies:
"@0x/types" "^2.5.0-beta.2" "@0x/types" "^2.5.0-beta.2"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
@ -983,7 +968,6 @@
"@0x/utils@^4.6.0-beta.2", "@0x/utils@^4.6.0-beta.3": "@0x/utils@^4.6.0-beta.2", "@0x/utils@^4.6.0-beta.3":
version "4.6.0-beta.3" version "4.6.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/utils/-/utils-4.6.0-beta.3.tgz#d40278916d98c48ea05821ae4987c88f032c7bff" resolved "https://registry.yarnpkg.com/@0x/utils/-/utils-4.6.0-beta.3.tgz#d40278916d98c48ea05821ae4987c88f032c7bff"
integrity sha512-aPIUgfhaDhwgddJAlIQJ2Ki87A60ovatBLCjareLUbsQSvFS5i3iujUBQHgFxZAv9tgl35fyg2ISEJ1YkQyubA==
dependencies: dependencies:
"@0x/types" "^2.5.0-beta.3" "@0x/types" "^2.5.0-beta.3"
"@0x/typescript-typings" "^4.4.0-beta.2" "@0x/typescript-typings" "^4.4.0-beta.2"
@ -1018,7 +1002,6 @@
"@0x/web3-wrapper@6.1.0-beta.2": "@0x/web3-wrapper@6.1.0-beta.2":
version "6.1.0-beta.2" version "6.1.0-beta.2"
resolved "https://registry.yarnpkg.com/@0x/web3-wrapper/-/web3-wrapper-6.1.0-beta.2.tgz#24aae8a0063057ebb6d3a7893a01d0abac8cd19c" resolved "https://registry.yarnpkg.com/@0x/web3-wrapper/-/web3-wrapper-6.1.0-beta.2.tgz#24aae8a0063057ebb6d3a7893a01d0abac8cd19c"
integrity sha512-XTurMsspRe089KybRbaEDUce/p25LjHBuGh5zMWb6OWctIoD7iJ2QHJOoH5AMJMlXObTO3CFwpwybbDmlbaKGQ==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.2" "@0x/assert" "^2.2.0-beta.2"
"@0x/json-schemas" "^4.1.0-beta.2" "@0x/json-schemas" "^4.1.0-beta.2"
@ -1032,7 +1015,6 @@
"@0x/web3-wrapper@^6.1.0-beta.2", "@0x/web3-wrapper@^6.1.0-beta.3": "@0x/web3-wrapper@^6.1.0-beta.2", "@0x/web3-wrapper@^6.1.0-beta.3":
version "6.1.0-beta.3" version "6.1.0-beta.3"
resolved "https://registry.yarnpkg.com/@0x/web3-wrapper/-/web3-wrapper-6.1.0-beta.3.tgz#82161147e9283391e0c7cd6027c971749c5a2f77" resolved "https://registry.yarnpkg.com/@0x/web3-wrapper/-/web3-wrapper-6.1.0-beta.3.tgz#82161147e9283391e0c7cd6027c971749c5a2f77"
integrity sha512-mc8120n8w88gICbDm8pkmC83Ul3RgE4BGsjY5BRBFefmKbv/XLeBZiWdhsaWYmkk8v4f+ZxAQ+HHTBDsRH87Og==
dependencies: dependencies:
"@0x/assert" "^2.2.0-beta.3" "@0x/assert" "^2.2.0-beta.3"
"@0x/json-schemas" "^4.1.0-beta.3" "@0x/json-schemas" "^4.1.0-beta.3"
@ -6768,7 +6750,6 @@ ethereum-types@^2.1.6:
ethereum-types@^2.2.0-beta.2: ethereum-types@^2.2.0-beta.2:
version "2.2.0-beta.2" version "2.2.0-beta.2"
resolved "https://registry.yarnpkg.com/ethereum-types/-/ethereum-types-2.2.0-beta.2.tgz#0b446842474c2afacd351258ed4a2d0841f2608f" resolved "https://registry.yarnpkg.com/ethereum-types/-/ethereum-types-2.2.0-beta.2.tgz#0b446842474c2afacd351258ed4a2d0841f2608f"
integrity sha512-5ANYHI/InHqf4Nt8oYrpvcph9/D6gi3sbM7Rlr8r0QjXb2mqocqEvOH460Zkf1robc7WDqurp9baeMy+um8kww==
dependencies: dependencies:
"@types/node" "*" "@types/node" "*"
bignumber.js "~9.0.0" bignumber.js "~9.0.0"