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

Cherry pick DevUtils refactor code from #2456

Browse Source
This commit is contained in:
Lawrence Forman
2020-01-31 15:56:08 -05:00
parent 8635849977
commit 4016808fa4
42 changed files with 1490 additions and 1041 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
contracts/integrations/test/dev-utils/dev_utils_mainnet_test.ts
View File

@@ -26,8 +26,9 @@ blockchainTests.fork.resets('DevUtils mainnet tests', env => {
before(async () => {
[noDaiAddress] = await env.getAccountAddressesAsync();
devUtils = await DevUtilsContract.deployFrom0xArtifactAsync(
devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
devUtilsArtifacts.DevUtils,
devUtilsArtifacts,
env.provider,
env.txDefaults,
devUtilsArtifacts,

3
contracts/integrations/test/dev-utils/get_order_hash.ts
View File

@@ -19,8 +19,9 @@ blockchainTests('DevUtils.getOrderHash', env => {
exchangeArtifacts,
new BigNumber(chainId),
);
devUtils = await DevUtilsContract.deployFrom0xArtifactAsync(
devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
artifacts.DevUtils,
artifacts,
env.provider,
env.txDefaults,
artifacts,

219
contracts/integrations/test/dev-utils/lib_asset_data.ts
View File

@@ -1,13 +1,13 @@
import * as crypto from 'crypto';
import { artifacts as proxyArtifacts, TestStaticCallTargetContract } from '@0x/contracts-asset-proxy';
import { artifacts, LibAssetDataContract } from '@0x/contracts-dev-utils';
import { artifacts, DevUtilsContract } from '@0x/contracts-dev-utils';
import { ERC1155MintableContract } from '@0x/contracts-erc1155';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { DummyERC721TokenContract } from '@0x/contracts-erc721';
import { blockchainTests, constants, expect } from '@0x/contracts-test-utils';
import { AssetProxyId } from '@0x/types';
import { BigNumber, hexUtils, LibBytesRevertErrors, StringRevertError } from '@0x/utils';
import { BigNumber, hexUtils, LibBytesRevertErrors } from '@0x/utils';
import { Actor } from '../framework/actors/base';
import { DeploymentManager } from '../framework/deployment_manager';
@@ -53,7 +53,7 @@ const KNOWN_STATIC_CALL_ENCODING = {
blockchainTests.resets('LibAssetData', env => {
let deployment: DeploymentManager;
let staticCallTarget: TestStaticCallTargetContract;
let libAssetData: LibAssetDataContract;
let devUtils: DevUtilsContract;
let tokenOwner: Actor;
@@ -73,8 +73,9 @@ blockchainTests.resets('LibAssetData', env => {
});
tokenOwner = new Actor({ name: 'Token Owner', deployment });
libAssetData = await LibAssetDataContract.deployFrom0xArtifactAsync(
artifacts.LibAssetData,
devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
artifacts.DevUtils,
artifacts,
env.provider,
env.txDefaults,
artifacts,
@@ -104,7 +105,7 @@ blockchainTests.resets('LibAssetData', env => {
});
it('should have a deployed-to address', () => {
expect(libAssetData.address.slice(0, 2)).to.equal('0x');
expect(devUtils.address.slice(0, 2)).to.equal('0x');
});
describe('encoding and decoding', () => {
@@ -117,17 +118,17 @@ blockchainTests.resets('LibAssetData', env => {
];
for (const [assetData, proxyId] of assetDataScenarios) {
expect(await libAssetData.decodeAssetProxyId(assetData).callAsync()).to.equal(proxyId);
expect(await devUtils.decodeAssetProxyId(assetData).callAsync()).to.equal(proxyId);
}
});
it('should encode ERC20 asset data', async () => {
expect(await libAssetData.encodeERC20AssetData(KNOWN_ERC20_ENCODING.address).callAsync()).to.equal(
expect(await devUtils.encodeERC20AssetData(KNOWN_ERC20_ENCODING.address).callAsync()).to.equal(
KNOWN_ERC20_ENCODING.assetData,
);
});
it('should decode ERC20 asset data', async () => {
expect(await libAssetData.decodeERC20AssetData(KNOWN_ERC20_ENCODING.assetData).callAsync()).to.deep.equal([
expect(await devUtils.decodeERC20AssetData(KNOWN_ERC20_ENCODING.assetData).callAsync()).to.deep.equal([
AssetProxyId.ERC20,
KNOWN_ERC20_ENCODING.address,
]);
@@ -135,21 +136,23 @@ blockchainTests.resets('LibAssetData', env => {
it('should encode ERC721 asset data', async () => {
expect(
await libAssetData
await devUtils
.encodeERC721AssetData(KNOWN_ERC721_ENCODING.address, KNOWN_ERC721_ENCODING.tokenId)
.callAsync(),
).to.equal(KNOWN_ERC721_ENCODING.assetData);
});
it('should decode ERC721 asset data', async () => {
expect(await libAssetData.decodeERC721AssetData(KNOWN_ERC721_ENCODING.assetData).callAsync()).to.deep.equal(
[AssetProxyId.ERC721, KNOWN_ERC721_ENCODING.address, KNOWN_ERC721_ENCODING.tokenId],
);
expect(await devUtils.decodeERC721AssetData(KNOWN_ERC721_ENCODING.assetData).callAsync()).to.deep.equal([
AssetProxyId.ERC721,
KNOWN_ERC721_ENCODING.address,
KNOWN_ERC721_ENCODING.tokenId,
]);
});
it('should encode ERC1155 asset data', async () => {
expect(
await libAssetData
await devUtils
.encodeERC1155AssetData(
KNOWN_ERC1155_ENCODING.tokenAddress,
KNOWN_ERC1155_ENCODING.tokenIds,
@@ -161,9 +164,7 @@ blockchainTests.resets('LibAssetData', env => {
});
it('should decode ERC1155 asset data', async () => {
expect(
await libAssetData.decodeERC1155AssetData(KNOWN_ERC1155_ENCODING.assetData).callAsync(),
).to.deep.equal([
expect(await devUtils.decodeERC1155AssetData(KNOWN_ERC1155_ENCODING.assetData).callAsync()).to.deep.equal([
AssetProxyId.ERC1155,
KNOWN_ERC1155_ENCODING.tokenAddress,
KNOWN_ERC1155_ENCODING.tokenIds,
@@ -174,7 +175,7 @@ blockchainTests.resets('LibAssetData', env => {
it('should encode multiasset data', async () => {
expect(
await libAssetData
await devUtils
.encodeMultiAssetData(
KNOWN_MULTI_ASSET_ENCODING.amounts,
KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
@@ -184,18 +185,18 @@ blockchainTests.resets('LibAssetData', env => {
});
it('should decode multiasset data', async () => {
expect(
await libAssetData.decodeMultiAssetData(KNOWN_MULTI_ASSET_ENCODING.assetData).callAsync(),
).to.deep.equal([
AssetProxyId.MultiAsset,
KNOWN_MULTI_ASSET_ENCODING.amounts,
KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
]);
expect(await devUtils.decodeMultiAssetData(KNOWN_MULTI_ASSET_ENCODING.assetData).callAsync()).to.deep.equal(
[
AssetProxyId.MultiAsset,
KNOWN_MULTI_ASSET_ENCODING.amounts,
KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
],
);
});
it('should encode StaticCall data', async () => {
expect(
await libAssetData
await devUtils
.encodeStaticCallAssetData(
KNOWN_STATIC_CALL_ENCODING.staticCallTargetAddress,
KNOWN_STATIC_CALL_ENCODING.staticCallData,
@@ -207,7 +208,7 @@ blockchainTests.resets('LibAssetData', env => {
it('should decode StaticCall data', async () => {
expect(
await libAssetData.decodeStaticCallAssetData(KNOWN_STATIC_CALL_ENCODING.assetData).callAsync(),
await devUtils.decodeStaticCallAssetData(KNOWN_STATIC_CALL_ENCODING.assetData).callAsync(),
).to.deep.equal([
AssetProxyId.StaticCall,
KNOWN_STATIC_CALL_ENCODING.staticCallTargetAddress,
@@ -227,16 +228,14 @@ blockchainTests.resets('LibAssetData', env => {
];
for (const data of assetData) {
await libAssetData.revertIfInvalidAssetData(data).callAsync();
await devUtils.revertIfInvalidAssetData(data).callAsync();
}
return;
});
it('should revert for invalid assetProxyId', async () => {
const badAssetData = `0x${crypto.randomBytes(4).toString('hex')}${constants.NULL_ADDRESS}`;
await expect(libAssetData.revertIfInvalidAssetData(badAssetData).callAsync()).to.eventually.be.rejectedWith(
StringRevertError,
);
await expect(devUtils.revertIfInvalidAssetData(badAssetData).callAsync()).to.revertWith('WRONG_PROXY_ID');
});
it('should revert for invalid assetData with valid assetProxyId', async () => {
@@ -245,8 +244,8 @@ blockchainTests.resets('LibAssetData', env => {
for (const data of assetData) {
const badData = data.substring(0, data.length - 2); // drop one byte but retain assetProxyId
await expect(libAssetData.revertIfInvalidAssetData(badData).callAsync()).to.eventually.be.rejectedWith(
LibBytesRevertErrors.InvalidByteOperationError,
await expect(devUtils.revertIfInvalidAssetData(badData).callAsync()).to.revertWith(
new LibBytesRevertErrors.InvalidByteOperationError(),
);
}
});
@@ -254,33 +253,31 @@ blockchainTests.resets('LibAssetData', env => {
describe('getBalance', () => {
it('should query ERC20 balance by asset data', async () => {
const assetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
const assetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.INITIAL_ERC20_BALANCE,
);
});
it('should return 0 if ERC20 token does not exist', async () => {
const assetData = await libAssetData.encodeERC20AssetData(constants.NULL_ADDRESS).callAsync();
const balance = await libAssetData.getBalance(tokenOwner.address, assetData).callAsync();
const assetData = await devUtils.encodeERC20AssetData(constants.NULL_ADDRESS).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, assetData).callAsync();
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
it('should query ERC721 balance by asset data', async () => {
const assetData = await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
const assetData = await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
});
it('should return 0 if ERC721 token does not exist', async () => {
const assetData = await libAssetData
.encodeERC721AssetData(constants.NULL_ADDRESS, erc721TokenId)
.callAsync();
const balance = await libAssetData.getBalance(tokenOwner.address, assetData).callAsync();
const assetData = await devUtils.encodeERC721AssetData(constants.NULL_ADDRESS, erc721TokenId).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, assetData).callAsync();
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
it('should query ERC1155 balances by asset data', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeERC1155AssetData(
erc1155Token.address,
[erc1155TokenId],
@@ -288,11 +285,11 @@ blockchainTests.resets('LibAssetData', env => {
constants.NULL_BYTES,
)
.callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
});
it('should return 0 if ERC1155 token does not exist', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeERC1155AssetData(
constants.NULL_ADDRESS,
[erc1155TokenId],
@@ -300,84 +297,84 @@ blockchainTests.resets('LibAssetData', env => {
constants.NULL_BYTES,
)
.callAsync();
const balance = await libAssetData.getBalance(tokenOwner.address, assetData).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, assetData).callAsync();
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
it('should query multi-asset batch balance by asset data', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
],
)
.callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
});
it('should query multi-asset batch balance by asset data, skipping over a nested asset if its amount == 0', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[constants.ZERO_AMOUNT, new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
],
)
.callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(1);
});
it('should return a balance of 0 if the balance for a nested asset is 0', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(secondErc20Token.address).callAsync(),
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC20AssetData(secondErc20Token.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
],
)
.callAsync();
expect(await libAssetData.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
expect(await devUtils.getBalance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.ZERO_AMOUNT,
);
});
it('should return a balance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
const fakeAssetData = '0x01020304';
const balance = await libAssetData.getBalance(tokenOwner.address, fakeAssetData).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, fakeAssetData).callAsync();
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
it('should return a balance of MAX_UINT256 if the the StaticCallProxy assetData contains data for a successful staticcall', async () => {
const staticCallData = staticCallTarget.isOddNumber(new BigNumber(1)).getABIEncodedTransactionData();
const expectedResultHash = hexUtils.hash(hexUtils.leftPad(1));
const assetData = await libAssetData
const assetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
.callAsync();
const balance = await libAssetData.getBalance(tokenOwner.address, assetData).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, assetData).callAsync();
expect(balance).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
});
it('should return a balance of 0 if the the StaticCallProxy assetData contains data for an unsuccessful staticcall', async () => {
const staticCallData = staticCallTarget.isOddNumber(new BigNumber(0)).getABIEncodedTransactionData();
const expectedResultHash = hexUtils.hash(hexUtils.leftPad(1));
const assetData = await libAssetData
const assetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, expectedResultHash)
.callAsync();
const balance = await libAssetData.getBalance(tokenOwner.address, assetData).callAsync();
const balance = await devUtils.getBalance(tokenOwner.address, assetData).callAsync();
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
});
describe('getAssetProxyAllowance', () => {
it('should query ERC20 allowances by asset data', async () => {
const assetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(constants.MAX_UINT256);
const assetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.MAX_UINT256,
);
});
it('should query ERC721 approval by asset data', async () => {
@@ -390,21 +387,21 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const assetData = await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(1);
const assetData = await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
1,
);
});
it('should query ERC721 approvalForAll by assetData', async () => {
const assetData = await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
const assetData = await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync();
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
);
});
it('should query ERC1155 allowances by asset data', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeERC1155AssetData(
erc1155Token.address,
[erc1155TokenId],
@@ -412,9 +409,9 @@ blockchainTests.resets('LibAssetData', env => {
constants.NULL_BYTES,
)
.callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
);
});
it('should query multi-asset allowances by asset data', async () => {
@@ -424,18 +421,18 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
],
)
.callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(1);
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
1,
);
return;
});
@@ -446,60 +443,60 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[constants.ZERO_AMOUNT, new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await libAssetData.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC721AssetData(erc721Token.address, erc721TokenId).callAsync(),
],
)
.callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
);
return;
});
it('should return an allowance of 0 if the allowance for a nested asset is 0', async () => {
const assetData = await libAssetData
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[
await libAssetData.encodeERC20AssetData(secondErc20Token.address).callAsync(),
await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync(),
await devUtils.encodeERC20AssetData(secondErc20Token.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20Token.address).callAsync(),
],
)
.callAsync();
expect(
await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.bignumber.equal(constants.ZERO_AMOUNT);
expect(await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync()).to.bignumber.equal(
constants.ZERO_AMOUNT,
);
});
it('should return an allowance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
const fakeAssetData = '0x01020304';
const allowance = await libAssetData.getAssetProxyAllowance(tokenOwner.address, fakeAssetData).callAsync();
const allowance = await devUtils.getAssetProxyAllowance(tokenOwner.address, fakeAssetData).callAsync();
expect(allowance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
it('should return an allowance of MAX_UINT256 for any staticCallAssetData', async () => {
const staticCallData = AssetProxyId.StaticCall;
const assetData = await libAssetData
const assetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, constants.KECCAK256_NULL)
.callAsync();
const allowance = await libAssetData.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync();
const allowance = await devUtils.getAssetProxyAllowance(tokenOwner.address, assetData).callAsync();
expect(allowance).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
});
});
describe('getBatchBalances', () => {
it('should query balances for a batch of asset data strings', async () => {
const erc20AssetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
const erc721AssetData = await libAssetData
const erc20AssetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
const erc721AssetData = await devUtils
.encodeERC721AssetData(erc721Token.address, erc721TokenId)
.callAsync();
expect(
await libAssetData.getBatchBalances(tokenOwner.address, [erc20AssetData, erc721AssetData]).callAsync(),
await devUtils.getBatchBalances(tokenOwner.address, [erc20AssetData, erc721AssetData]).callAsync(),
).to.deep.equal([new BigNumber(constants.INITIAL_ERC20_BALANCE), new BigNumber(1)]);
});
});
@@ -512,9 +509,9 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const assetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
const assetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
expect(
await libAssetData.getBalanceAndAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
await devUtils.getBalanceAndAssetProxyAllowance(tokenOwner.address, assetData).callAsync(),
).to.deep.equal([new BigNumber(constants.INITIAL_ERC20_BALANCE), allowance]);
});
});
@@ -526,9 +523,9 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const assetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
const assetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
expect(
await libAssetData.getBatchBalancesAndAssetProxyAllowances(tokenOwner.address, [assetData]).callAsync(),
await devUtils.getBatchBalancesAndAssetProxyAllowances(tokenOwner.address, [assetData]).callAsync(),
).to.deep.equal([[new BigNumber(constants.INITIAL_ERC20_BALANCE)], [allowance]]);
});
});
@@ -541,12 +538,12 @@ blockchainTests.resets('LibAssetData', env => {
.awaitTransactionSuccessAsync({
from: tokenOwner.address,
});
const erc20AssetData = await libAssetData.encodeERC20AssetData(erc20Token.address).callAsync();
const erc721AssetData = await libAssetData
const erc20AssetData = await devUtils.encodeERC20AssetData(erc20Token.address).callAsync();
const erc721AssetData = await devUtils
.encodeERC721AssetData(erc721Token.address, erc721TokenId)
.callAsync();
expect(
await libAssetData
await devUtils
.getBatchAssetProxyAllowances(tokenOwner.address, [erc20AssetData, erc721AssetData])
.callAsync(),
).to.deep.equal([allowance, constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS]);

54
contracts/integrations/test/dev-utils/lib_transaction_decoder.ts
View File

@@ -1,14 +1,8 @@
import { ExchangeContract } from '@0x/contracts-exchange';
import { chaiSetup, constants, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils';
import { artifacts as exchangeArtifacts, ExchangeContract } from '@0x/contracts-exchange';
import { blockchainTests, constants, expect } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils';
import * as chai from 'chai';
import { artifacts, LibTransactionDecoderContract } from '@0x/contracts-dev-utils';
chaiSetup.configure();
const expect = chai.expect;
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
import { artifacts, DevUtilsContract } from '@0x/contracts-dev-utils';
const order = {
makerAddress: '0xe36ea790bc9d7ab70c55260c66d52b1eca985f84',
@@ -30,25 +24,31 @@ const takerAssetFillAmount = new BigNumber('100000000000000000000');
const signature =
'0x1ce8e3c600d933423172b5021158a6be2e818613ff8e762d70ef490c752fd98a626a215f09f169668990414de75a53da221c294a3002f796d004827258b641876e03';
describe('LibTransactionDecoder', () => {
let libTxDecoder: LibTransactionDecoderContract;
const exchangeInterface = new ExchangeContract(constants.NULL_ADDRESS, provider, txDefaults);
blockchainTests('LibTransactionDecoder', env => {
let devUtils: DevUtilsContract;
const exchangeInterface = new ExchangeContract(constants.NULL_ADDRESS, { isEIP1193: true } as any);
before(async () => {
await blockchainLifecycle.startAsync();
libTxDecoder = await LibTransactionDecoderContract.deployFrom0xArtifactAsync(
artifacts.LibTransactionDecoder,
provider,
txDefaults,
artifacts,
const exchange = await ExchangeContract.deployFrom0xArtifactAsync(
exchangeArtifacts.Exchange,
env.provider,
env.txDefaults,
exchangeArtifacts,
new BigNumber(1),
);
devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
artifacts.DevUtils,
artifacts,
env.provider,
env.txDefaults,
artifacts,
exchange.address,
constants.NULL_ADDRESS,
);
});
after(async () => {
await blockchainLifecycle.revertAsync();
});
it('should decode an Exchange.batchCancelOrders() transaction', async () => {
const input = exchangeInterface.batchCancelOrders([order, order]).getABIEncodedTransactionData();
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
'batchCancelOrders',
[order, order],
[],
@@ -61,7 +61,7 @@ describe('LibTransactionDecoder', () => {
[func]([order, order], [takerAssetFillAmount, takerAssetFillAmount], [signature, signature])
.getABIEncodedTransactionData();
it(`should decode an Exchange.${func}() transaction`, async () => {
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
func,
[order, order],
[takerAssetFillAmount, takerAssetFillAmount],
@@ -72,7 +72,7 @@ describe('LibTransactionDecoder', () => {
it('should decode an Exchange.cancelOrder() transaction', async () => {
const input = exchangeInterface.cancelOrder(order).getABIEncodedTransactionData();
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
'cancelOrder',
[order],
[],
@@ -85,7 +85,7 @@ describe('LibTransactionDecoder', () => {
[func](order, takerAssetFillAmount, signature)
.getABIEncodedTransactionData();
it(`should decode an Exchange.${func}() transaction`, async () => {
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
func,
[order],
[takerAssetFillAmount],
@@ -104,7 +104,7 @@ describe('LibTransactionDecoder', () => {
[func]([order, order], takerAssetFillAmount, [signature, signature])
.getABIEncodedTransactionData();
it(`should decode an Exchange.${func}() transaction`, async () => {
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
func,
[order, order],
[takerAssetFillAmount],
@@ -130,7 +130,7 @@ describe('LibTransactionDecoder', () => {
const input = exchangeInterface
.matchOrders(order, complementaryOrder, signature, signature)
.getABIEncodedTransactionData();
expect(await libTxDecoder.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
expect(await devUtils.decodeZeroExTransactionData(input).callAsync()).to.deep.equal([
'matchOrders',
[order, complementaryOrder],
[order.takerAssetAmount, complementaryOrder.takerAssetAmount],

3
contracts/integrations/test/framework/deployment_manager.ts
View File

@@ -195,8 +195,9 @@ export class DeploymentManager {
exchange,
staking.stakingProxy,
]);
const devUtils = await DevUtilsContract.deployFrom0xArtifactAsync(
const devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
devUtilsArtifacts.DevUtils,
devUtilsArtifacts,
environment.provider,
environment.txDefaults,
devUtilsArtifacts,