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

Cherry-pick changes from feat/dev-utils/dydx-bridge-validation

Browse Source
This commit is contained in:
Lawrence Forman
2020-01-31 11:40:31 -05:00
parent 79362b0dba
commit 3e8f9a6b53
104 changed files with 1699 additions and 1434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
contracts/integrations/CHANGELOG.json
View File

@@ -1,4 +1,13 @@
[
{
"version": "2.3.0",
"changes": [
{
"note": "Remove dependency on `DevUtils` for asset data encoding/decoding",
"pr": 2462
}
]
},
{
"timestamp": 1580988106,
"version": "2.2.3",

9
contracts/integrations/test/coordinator/client_test.ts
View File

@@ -1,5 +1,5 @@
import { ContractAddresses, getContractAddressesForChainOrThrow } from '@0x/contract-addresses';
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { ExchangeContract } from '@0x/contracts-exchange';
import { blockchainTests, constants, expect, OrderFactory } from '@0x/contracts-test-utils';
import { defaultOrmConfig, getAppAsync } from '@0x/coordinator-server';
@@ -22,7 +22,6 @@ const DEFAULT_PROTOCOL_FEE_MULTIPLIER = new BigNumber(150000);
blockchainTests.skip('Coordinator Client', env => {
const takerTokenFillAmount = new BigNumber(0);
const chainId = 1337;
const assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
let contractAddresses: ContractAddresses;
let coordinatorRegistry: CoordinatorRegistryContract;
@@ -80,9 +79,9 @@ blockchainTests.skip('Coordinator Client', env => {
const [makerTokenAddress, takerTokenAddress] = tokenUtils.getDummyERC20TokenAddresses();
const feeTokenAddress = contractAddresses.zrxToken;
[makerAssetData, takerAssetData, feeAssetData] = [
assetDataEncoder.ERC20Token(makerTokenAddress).getABIEncodedTransactionData(),
assetDataEncoder.ERC20Token(takerTokenAddress).getABIEncodedTransactionData(),
assetDataEncoder.ERC20Token(feeTokenAddress).getABIEncodedTransactionData(),
encodeERC20AssetData(makerTokenAddress),
encodeERC20AssetData(takerTokenAddress),
encodeERC20AssetData(feeTokenAddress),
];
// set initial balances

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

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { CoordinatorContract, CoordinatorRevertErrors, SignedCoordinatorApproval } from '@0x/contracts-coordinator';
import {
ExchangeCancelEventArgs,
@@ -60,18 +61,10 @@ blockchainTests.resets('Coordinator integration tests', env => {
orderConfig: {
senderAddress: coordinator.address,
feeRecipientAddress: feeRecipient.address,
makerAssetData: deployment.assetDataEncoder
.ERC20Token(makerToken.address)
.getABIEncodedTransactionData(),
takerAssetData: deployment.assetDataEncoder
.ERC20Token(takerToken.address)
.getABIEncodedTransactionData(),
makerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(makerFeeToken.address)
.getABIEncodedTransactionData(),
takerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(takerFeeToken.address)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
makerFeeAssetData: encodeERC20AssetData(makerFeeToken.address),
takerFeeAssetData: encodeERC20AssetData(takerFeeToken.address),
},
});

24
contracts/integrations/test/exchange/batch_match_orders_test.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC1155AssetData, encodeERC20AssetData, encodeERC721AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { ExchangeRevertErrors } from '@0x/contracts-exchange';
import { blockchainTests, constants, expect, toBaseUnitAmount } from '@0x/contracts-test-utils';
@@ -61,13 +62,9 @@ blockchainTests.resets('matchOrders integration tests', env => {
});
// Encode the asset data.
makerAssetDataLeft = deployment.assetDataEncoder
.ERC20Token(makerAssetLeft.address)
.getABIEncodedTransactionData();
makerAssetDataRight = deployment.assetDataEncoder
.ERC20Token(makerAssetRight.address)
.getABIEncodedTransactionData();
feeAssetData = deployment.assetDataEncoder.ERC20Token(feeAsset.address).getABIEncodedTransactionData();
makerAssetDataLeft = encodeERC20AssetData(makerAssetLeft.address);
makerAssetDataRight = encodeERC20AssetData(makerAssetRight.address);
feeAssetData = encodeERC20AssetData(feeAsset.address);
// Create two market makers with compatible orders for matching.
makerLeft = new Maker({
@@ -812,12 +809,13 @@ blockchainTests.resets('matchOrders integration tests', env => {
describe('token sanity checks', () => {
it('should be able to match ERC721 tokens with ERC1155 tokens', async () => {
const leftMakerAssetData = deployment.assetDataEncoder
.ERC1155Assets(deployment.tokens.erc1155[0].address, [leftId], [new BigNumber(1)], '0x')
.getABIEncodedTransactionData();
const rightMakerAssetData = deployment.assetDataEncoder
.ERC721Token(deployment.tokens.erc721[0].address, rightId)
.getABIEncodedTransactionData();
const leftMakerAssetData = encodeERC1155AssetData(
deployment.tokens.erc1155[0].address,
[leftId],
[new BigNumber(1)],
'0x',
);
const rightMakerAssetData = encodeERC721AssetData(deployment.tokens.erc721[0].address, rightId);
const signedOrderLeft = await makerLeft.signOrderAsync({
makerAssetAmount: new BigNumber(4),

280
contracts/integrations/test/exchange/core_test.ts
View File

@@ -1,5 +1,10 @@
import {
artifacts as proxyArtifacts,
encodeERC1155AssetData,
encodeERC20AssetData,
encodeERC721AssetData,
encodeMultiAssetData,
encodeStaticCallAssetData,
ERC1155ProxyContract,
ERC1155ProxyWrapper,
ERC20ProxyContract,
@@ -10,7 +15,6 @@ import {
StaticCallProxyContract,
TestStaticCallTargetContract,
} from '@0x/contracts-asset-proxy';
import { DevUtilsContract } from '@0x/contracts-dev-utils';
import { ERC1155MintableContract, Erc1155Wrapper } from '@0x/contracts-erc1155';
import {
artifacts as erc20Artifacts,
@@ -51,7 +55,6 @@ blockchainTests.resets('Exchange core', () => {
let takerAddress: string;
let feeRecipientAddress: string;
let devUtils: DevUtilsContract;
let erc20TokenA: DummyERC20TokenContract;
let erc20TokenB: DummyERC20TokenContract;
let feeToken: DummyERC20TokenContract;
@@ -91,7 +94,6 @@ blockchainTests.resets('Exchange core', () => {
const accounts = await web3Wrapper.getAvailableAddressesAsync();
const usedAddresses = ([owner, makerAddress, takerAddress, feeRecipientAddress] = _.slice(accounts, 0, 4));
devUtils = new DevUtilsContract(constants.NULL_ADDRESS, provider);
erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
erc1155ProxyWrapper = new ERC1155ProxyWrapper(provider, usedAddresses, owner);
@@ -195,10 +197,10 @@ blockchainTests.resets('Exchange core', () => {
...constants.STATIC_ORDER_PARAMS,
makerAddress,
feeRecipientAddress,
makerAssetData: await devUtils.encodeERC20AssetData(defaultMakerAssetAddress).callAsync(),
takerAssetData: await devUtils.encodeERC20AssetData(defaultTakerAssetAddress).callAsync(),
makerFeeAssetData: await devUtils.encodeERC20AssetData(defaultFeeAssetAddress).callAsync(),
takerFeeAssetData: await devUtils.encodeERC20AssetData(defaultFeeAssetAddress).callAsync(),
makerAssetData: encodeERC20AssetData(defaultMakerAssetAddress),
takerAssetData: encodeERC20AssetData(defaultTakerAssetAddress),
makerFeeAssetData: encodeERC20AssetData(defaultFeeAssetAddress),
takerFeeAssetData: encodeERC20AssetData(defaultFeeAssetAddress),
exchangeAddress: exchange.address,
chainId,
};
@@ -289,11 +291,9 @@ blockchainTests.resets('Exchange core', () => {
describe('Fill transfer ordering', () => {
it('should allow the maker to exchange assets received by the taker', async () => {
// Set maker/taker assetData to the same asset
const takerAssetData = await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync();
const takerAssetData = encodeERC20AssetData(erc20TokenA.address);
const takerAssetAmount = new BigNumber(1);
const makerAssetData = await devUtils
.encodeMultiAssetData([takerAssetAmount], [takerAssetData])
.callAsync();
const makerAssetData = encodeMultiAssetData([takerAssetAmount], [takerAssetData]);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -309,7 +309,7 @@ blockchainTests.resets('Exchange core', () => {
await fillOrderWrapper.fillOrderAndAssertEffectsAsync(signedOrder, takerAddress);
});
it('should allow the taker to pay fees with an asset that received by the maker', async () => {
const makerAssetData = await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync();
const makerAssetData = encodeERC20AssetData(erc20TokenA.address);
signedOrder = await orderFactory.newSignedOrderAsync({
takerFeeAssetData: makerAssetData,
makerFee: constants.ZERO_AMOUNT,
@@ -322,7 +322,7 @@ blockchainTests.resets('Exchange core', () => {
await fillOrderWrapper.fillOrderAndAssertEffectsAsync(signedOrder, takerAddress);
});
it('should allow the maker to pay fees with an asset that received by the taker', async () => {
const takerAssetData = await devUtils.encodeERC20AssetData(erc20TokenB.address).callAsync();
const takerAssetData = encodeERC20AssetData(erc20TokenB.address);
signedOrder = await orderFactory.newSignedOrderAsync({
makerFeeAssetData: takerAssetData,
makerFee: new BigNumber(1),
@@ -346,7 +346,7 @@ blockchainTests.resets('Exchange core', () => {
});
it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData: await devUtils.encodeERC20AssetData(noReturnErc20Token.address).callAsync(),
makerAssetData: encodeERC20AssetData(noReturnErc20Token.address),
makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
});
@@ -354,7 +354,7 @@ blockchainTests.resets('Exchange core', () => {
});
it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData: await devUtils.encodeERC20AssetData(noReturnErc20Token.address).callAsync(),
makerAssetData: encodeERC20AssetData(noReturnErc20Token.address),
makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
});
@@ -362,7 +362,7 @@ blockchainTests.resets('Exchange core', () => {
});
it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData: await devUtils.encodeERC20AssetData(noReturnErc20Token.address).callAsync(),
makerAssetData: encodeERC20AssetData(noReturnErc20Token.address),
makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
});
@@ -544,8 +544,8 @@ blockchainTests.resets('Exchange core', () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1),
takerAssetAmount: new BigNumber(1),
makerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, makerAssetId).callAsync(),
takerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, takerAssetId).callAsync(),
makerAssetData: encodeERC721AssetData(erc721Token.address, makerAssetId),
takerAssetData: encodeERC721AssetData(erc721Token.address, takerAssetId),
});
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
// Verify pre-conditions
@@ -573,8 +573,8 @@ blockchainTests.resets('Exchange core', () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1),
takerAssetAmount: new BigNumber(1),
makerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, makerAssetId).callAsync(),
takerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, takerAssetId).callAsync(),
makerAssetData: encodeERC721AssetData(erc721Token.address, makerAssetId),
takerAssetData: encodeERC721AssetData(erc721Token.address, takerAssetId),
});
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
// Verify pre-conditions
@@ -602,8 +602,8 @@ blockchainTests.resets('Exchange core', () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(2),
takerAssetAmount: new BigNumber(1),
makerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, makerAssetId).callAsync(),
takerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, takerAssetId).callAsync(),
makerAssetData: encodeERC721AssetData(erc721Token.address, makerAssetId),
takerAssetData: encodeERC721AssetData(erc721Token.address, takerAssetId),
});
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
// Verify pre-conditions
@@ -631,8 +631,8 @@ blockchainTests.resets('Exchange core', () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1),
takerAssetAmount: new BigNumber(500),
makerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, makerAssetId).callAsync(),
takerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, takerAssetId).callAsync(),
makerAssetData: encodeERC721AssetData(erc721Token.address, makerAssetId),
takerAssetData: encodeERC721AssetData(erc721Token.address, takerAssetId),
});
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
// Verify pre-conditions
@@ -659,8 +659,8 @@ blockchainTests.resets('Exchange core', () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1),
takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
makerAssetData: await devUtils.encodeERC721AssetData(erc721Token.address, makerAssetId).callAsync(),
takerAssetData: await devUtils.encodeERC20AssetData(defaultTakerAssetAddress).callAsync(),
makerAssetData: encodeERC721AssetData(erc721Token.address, makerAssetId),
takerAssetData: encodeERC20AssetData(defaultTakerAssetAddress),
});
// Call Exchange
const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
@@ -680,12 +680,12 @@ blockchainTests.resets('Exchange core', () => {
it('should allow multiple assets to be exchanged for a single asset', async () => {
const makerAmounts = [new BigNumber(10), new BigNumber(20)];
const makerNestedAssetData = [
await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20TokenB.address).callAsync(),
encodeERC20AssetData(erc20TokenA.address),
encodeERC20AssetData(erc20TokenB.address),
];
const makerAssetData = await devUtils.encodeMultiAssetData(makerAmounts, makerNestedAssetData).callAsync();
const makerAssetData = encodeMultiAssetData(makerAmounts, makerNestedAssetData);
const makerAssetAmount = new BigNumber(1);
const takerAssetData = await devUtils.encodeERC20AssetData(feeToken.address).callAsync();
const takerAssetData = encodeERC20AssetData(feeToken.address);
const takerAssetAmount = new BigNumber(10);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
@@ -700,18 +700,18 @@ blockchainTests.resets('Exchange core', () => {
it('should allow multiple assets to be exchanged for multiple assets', async () => {
const makerAmounts = [new BigNumber(10), new BigNumber(20)];
const makerNestedAssetData = [
await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20TokenB.address).callAsync(),
encodeERC20AssetData(erc20TokenA.address),
encodeERC20AssetData(erc20TokenB.address),
];
const makerAssetData = await devUtils.encodeMultiAssetData(makerAmounts, makerNestedAssetData).callAsync();
const makerAssetData = encodeMultiAssetData(makerAmounts, makerNestedAssetData);
const makerAssetAmount = new BigNumber(1);
const takerAmounts = [new BigNumber(10), new BigNumber(1)];
const takerAssetId = erc721TakerAssetIds[0];
const takerNestedAssetData = [
await devUtils.encodeERC20AssetData(feeToken.address).callAsync(),
await devUtils.encodeERC721AssetData(erc721Token.address, takerAssetId).callAsync(),
encodeERC20AssetData(feeToken.address),
encodeERC721AssetData(erc721Token.address, takerAssetId),
];
const takerAssetData = await devUtils.encodeMultiAssetData(takerAmounts, takerNestedAssetData).callAsync();
const takerAssetData = encodeMultiAssetData(takerAmounts, takerNestedAssetData);
const takerAssetAmount = new BigNumber(1);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
@@ -726,12 +726,12 @@ blockchainTests.resets('Exchange core', () => {
it('should allow an order selling multiple assets to be partially filled', async () => {
const makerAmounts = [new BigNumber(10), new BigNumber(20)];
const makerNestedAssetData = [
await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20TokenB.address).callAsync(),
encodeERC20AssetData(erc20TokenA.address),
encodeERC20AssetData(erc20TokenB.address),
];
const makerAssetData = await devUtils.encodeMultiAssetData(makerAmounts, makerNestedAssetData).callAsync();
const makerAssetData = encodeMultiAssetData(makerAmounts, makerNestedAssetData);
const makerAssetAmount = new BigNumber(30);
const takerAssetData = await devUtils.encodeERC20AssetData(feeToken.address).callAsync();
const takerAssetData = encodeERC20AssetData(feeToken.address);
const takerAssetAmount = new BigNumber(10);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
@@ -748,12 +748,12 @@ blockchainTests.resets('Exchange core', () => {
it('should allow an order buying multiple assets to be partially filled', async () => {
const takerAmounts = [new BigNumber(10), new BigNumber(20)];
const takerNestedAssetData = [
await devUtils.encodeERC20AssetData(erc20TokenA.address).callAsync(),
await devUtils.encodeERC20AssetData(erc20TokenB.address).callAsync(),
encodeERC20AssetData(erc20TokenA.address),
encodeERC20AssetData(erc20TokenB.address),
];
const takerAssetData = await devUtils.encodeMultiAssetData(takerAmounts, takerNestedAssetData).callAsync();
const takerAssetData = encodeMultiAssetData(takerAmounts, takerNestedAssetData);
const takerAssetAmount = new BigNumber(30);
const makerAssetData = await devUtils.encodeERC20AssetData(feeToken.address).callAsync();
const makerAssetData = encodeERC20AssetData(feeToken.address);
const makerAssetAmount = new BigNumber(10);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
@@ -779,22 +779,18 @@ blockchainTests.resets('Exchange core', () => {
const makerAssetAmount = new BigNumber(1);
const takerAssetAmount = new BigNumber(1);
const receiverCallbackData = '0x';
const makerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const takerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const makerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
);
const takerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -818,22 +814,18 @@ blockchainTests.resets('Exchange core', () => {
const makerAssetAmount = new BigNumber(1);
const takerAssetAmount = new BigNumber(1);
const receiverCallbackData = '0x';
const makerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const takerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const makerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
);
const takerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -856,22 +848,18 @@ blockchainTests.resets('Exchange core', () => {
const makerAssetAmount = new BigNumber(1);
const takerAssetAmount = new BigNumber(1);
const receiverCallbackData = '0x';
const makerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const takerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const makerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
);
const takerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -900,22 +888,18 @@ blockchainTests.resets('Exchange core', () => {
const makerAssetAmount = new BigNumber(1);
const takerAssetAmount = new BigNumber(1);
const receiverCallbackData = '0x';
const makerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const takerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const makerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
);
const takerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -949,22 +933,18 @@ blockchainTests.resets('Exchange core', () => {
const makerAssetAmount = new BigNumber(10);
const takerAssetAmount = new BigNumber(20);
const receiverCallbackData = '0x';
const makerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const takerAssetData = await devUtils
.encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
)
.callAsync();
const makerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
makerAssetsToTransfer,
makerValuesToTransfer,
receiverCallbackData,
);
const takerAssetData = encodeERC1155AssetData(
erc1155Contract.address,
takerAssetsToTransfer,
takerValuesToTransfer,
receiverCallbackData,
);
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetData,
takerAssetData,
@@ -990,9 +970,11 @@ blockchainTests.resets('Exchange core', () => {
});
it('should revert if the staticcall is unsuccessful', async () => {
const staticCallData = staticCallTarget.assertEvenNumber(new BigNumber(1)).getABIEncodedTransactionData();
const assetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, constants.KECCAK256_NULL)
.callAsync();
const assetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallData,
constants.KECCAK256_NULL,
);
signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: assetData });
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const expectedError = new ExchangeRevertErrors.AssetProxyTransferError(
@@ -1009,23 +991,25 @@ blockchainTests.resets('Exchange core', () => {
const staticCallData = staticCallTarget
.assertEvenNumber(constants.ZERO_AMOUNT)
.getABIEncodedTransactionData();
const assetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, constants.KECCAK256_NULL)
.callAsync();
const assetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallData,
constants.KECCAK256_NULL,
);
signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: assetData });
await fillOrderWrapper.fillOrderAndAssertEffectsAsync(signedOrder, takerAddress);
});
it('should revert if the staticcall is unsuccessful using the MultiAssetProxy', async () => {
const staticCallData = staticCallTarget.assertEvenNumber(new BigNumber(1)).getABIEncodedTransactionData();
const staticCallAssetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, constants.KECCAK256_NULL)
.callAsync();
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[await devUtils.encodeERC20AssetData(defaultMakerAssetAddress).callAsync(), staticCallAssetData],
)
.callAsync();
const staticCallAssetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallData,
constants.KECCAK256_NULL,
);
const assetData = encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[encodeERC20AssetData(defaultMakerAssetAddress), staticCallAssetData],
);
signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: assetData });
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
const expectedError = new ExchangeRevertErrors.AssetProxyTransferError(
@@ -1042,15 +1026,15 @@ blockchainTests.resets('Exchange core', () => {
const staticCallData = staticCallTarget
.assertEvenNumber(constants.ZERO_AMOUNT)
.getABIEncodedTransactionData();
const staticCallAssetData = await devUtils
.encodeStaticCallAssetData(staticCallTarget.address, staticCallData, constants.KECCAK256_NULL)
.callAsync();
const assetData = await devUtils
.encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[await devUtils.encodeERC20AssetData(defaultMakerAssetAddress).callAsync(), staticCallAssetData],
)
.callAsync();
const staticCallAssetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallData,
constants.KECCAK256_NULL,
);
const assetData = encodeMultiAssetData(
[new BigNumber(1), new BigNumber(1)],
[encodeERC20AssetData(defaultMakerAssetAddress), staticCallAssetData],
);
signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetData: assetData });
await fillOrderWrapper.fillOrderAndAssertEffectsAsync(signedOrder, takerAddress);
});

37
contracts/integrations/test/exchange/exchange_wrapper_test.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract, ERC20TokenEvents, ERC20TokenTransferEventArgs } from '@0x/contracts-erc20';
import { ExchangeRevertErrors, IExchangeEvents, IExchangeFillEventArgs } from '@0x/contracts-exchange';
import { ReferenceFunctions } from '@0x/contracts-exchange-libs';
@@ -65,18 +66,10 @@ blockchainTests.resets('Exchange wrappers', env => {
name: 'market maker',
deployment,
orderConfig: {
makerAssetData: deployment.assetDataEncoder
.ERC20Token(makerToken.address)
.getABIEncodedTransactionData(),
takerAssetData: deployment.assetDataEncoder
.ERC20Token(takerToken.address)
.getABIEncodedTransactionData(),
makerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData(),
takerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
makerFeeAssetData: encodeERC20AssetData(feeToken.address),
takerFeeAssetData: encodeERC20AssetData(feeToken.address),
feeRecipientAddress: feeRecipient,
},
});
@@ -114,9 +107,7 @@ blockchainTests.resets('Exchange wrappers', env => {
initialLocalBalances = LocalBalanceStore.create(blockchainBalances);
wethAssetData = deployment.assetDataEncoder
.ERC20Token(deployment.tokens.weth.address)
.getABIEncodedTransactionData();
wethAssetData = encodeERC20AssetData(deployment.tokens.weth.address);
});
beforeEach(async () => {
@@ -788,9 +779,7 @@ blockchainTests.resets('Exchange wrappers', env => {
});
it('should fill a signedOrder that does not use the same takerAssetAddress (eth protocol fee)', async () => {
const differentTakerAssetData = deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData();
const differentTakerAssetData = encodeERC20AssetData(feeToken.address);
signedOrders = [
await maker.signOrderAsync(),
@@ -811,9 +800,7 @@ blockchainTests.resets('Exchange wrappers', env => {
});
it('should fill a signedOrder that does not use the same takerAssetAddress (weth protocol fee)', async () => {
const differentTakerAssetData = deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData();
const differentTakerAssetData = encodeERC20AssetData(feeToken.address);
signedOrders = [
await maker.signOrderAsync(),
@@ -986,9 +973,7 @@ blockchainTests.resets('Exchange wrappers', env => {
});
it('should fill a signedOrder that does not use the same makerAssetAddress (eth protocol fee)', async () => {
const differentMakerAssetData = deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData();
const differentMakerAssetData = encodeERC20AssetData(feeToken.address);
signedOrders = [
await maker.signOrderAsync(),
@@ -1010,9 +995,7 @@ blockchainTests.resets('Exchange wrappers', env => {
});
it('should fill a signedOrder that does not use the same makerAssetAddress (weth protocol fee)', async () => {
const differentMakerAssetData = deployment.assetDataEncoder
.ERC20Token(feeToken.address)
.getABIEncodedTransactionData();
const differentMakerAssetData = encodeERC20AssetData(feeToken.address);
signedOrders = [
await maker.signOrderAsync(),

36
contracts/integrations/test/exchange/fill_dydx_order_test.ts
View File

@@ -1,4 +1,10 @@
import { DydxBridgeActionType, dydxBridgeDataEncoder, TestDydxBridgeContract } from '@0x/contracts-asset-proxy';
import {
DydxBridgeActionType,
dydxBridgeDataEncoder,
encodeERC20AssetData,
encodeERC20BridgeAssetData,
TestDydxBridgeContract,
} from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { LibMathRevertErrors } from '@0x/contracts-exchange-libs';
import { blockchainTests, constants, describe, expect, toBaseUnitAmount } from '@0x/contracts-test-utils';
@@ -53,25 +59,23 @@ blockchainTests.resets('Exchange fills dydx orders', env => {
testContract = await deployDydxBridgeAsync(deployment, env);
const encodedBridgeData = dydxBridgeDataEncoder.encode({ bridgeData });
testTokenAddress = await testContract.getTestToken().callAsync();
dydxBridgeProxyAssetData = deployment.assetDataEncoder
.ERC20Bridge(testTokenAddress, testContract.address, encodedBridgeData)
.getABIEncodedTransactionData();
dydxBridgeProxyAssetData = encodeERC20BridgeAssetData(
testTokenAddress,
testContract.address,
encodedBridgeData,
);
[makerToken, takerToken] = deployment.tokens.erc20;
// Configure default order parameters.
orderConfig = {
makerAssetAmount: toBaseUnitAmount(1),
takerAssetAmount: toBaseUnitAmount(1),
makerAssetData: deployment.assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData(),
takerAssetData: deployment.assetDataEncoder.ERC20Token(takerToken.address).getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
// Not important for this test.
feeRecipientAddress: constants.NULL_ADDRESS,
makerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(makerToken.address)
.getABIEncodedTransactionData(),
takerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(takerToken.address)
.getABIEncodedTransactionData(),
makerFeeAssetData: encodeERC20AssetData(makerToken.address),
takerFeeAssetData: encodeERC20AssetData(takerToken.address),
makerFee: toBaseUnitAmount(1),
takerFee: toBaseUnitAmount(1),
};
@@ -244,9 +248,11 @@ blockchainTests.resets('Exchange fills dydx orders', env => {
actions: [badDepositAction],
};
const encodedBridgeData = dydxBridgeDataEncoder.encode({ bridgeData: badBridgeData });
const badDydxBridgeProxyAssetData = deployment.assetDataEncoder
.ERC20Bridge(testTokenAddress, testContract.address, encodedBridgeData)
.getABIEncodedTransactionData();
const badDydxBridgeProxyAssetData = encodeERC20BridgeAssetData(
testTokenAddress,
testContract.address,
encodedBridgeData,
);
const signedOrder = await maker.signOrderAsync({
makerAssetData: badDydxBridgeProxyAssetData,
makerAssetAmount: badDepositAction.conversionRateDenominator,

17
contracts/integrations/test/exchange/fill_order_test.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { ERC20TokenEvents, ERC20TokenTransferEventArgs } from '@0x/contracts-erc20';
import { ExchangeEvents, ExchangeFillEventArgs } from '@0x/contracts-exchange';
import { ReferenceFunctions } from '@0x/contracts-exchange-libs';
@@ -58,14 +59,10 @@ blockchainTests.resets('fillOrder integration tests', env => {
});
const orderConfig = {
feeRecipientAddress: feeRecipient.address,
makerAssetData: deployment.assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData(),
takerAssetData: deployment.assetDataEncoder.ERC20Token(takerToken.address).getABIEncodedTransactionData(),
makerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(makerToken.address)
.getABIEncodedTransactionData(),
takerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(takerToken.address)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
makerFeeAssetData: encodeERC20AssetData(makerToken.address),
takerFeeAssetData: encodeERC20AssetData(takerToken.address),
makerFee: constants.ZERO_AMOUNT,
takerFee: constants.ZERO_AMOUNT,
};
@@ -271,7 +268,7 @@ blockchainTests.resets('fillOrder integration tests', env => {
deployment.staking.stakingProxy.address,
operator.address,
operatorReward,
deployment.assetDataEncoder.ERC20Token(deployment.tokens.weth.address).getABIEncodedTransactionData(),
encodeERC20AssetData(deployment.tokens.weth.address),
);
expectedBalances.burnGas(delegator.address, DeploymentManager.gasPrice.times(finalizePoolReceipt.gasUsed));
await balanceStore.updateBalancesAsync();
@@ -354,7 +351,7 @@ blockchainTests.resets('fillOrder integration tests', env => {
deployment.staking.stakingProxy.address,
operator.address,
operatorReward,
deployment.assetDataEncoder.ERC20Token(deployment.tokens.weth.address).getABIEncodedTransactionData(),
encodeERC20AssetData(deployment.tokens.weth.address),
);
expectedBalances.burnGas(delegator.address, DeploymentManager.gasPrice.times(finalizePoolReceipt.gasUsed));
await balanceStore.updateBalancesAsync();

5
contracts/integrations/test/exchange/match_order_tester.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { BlockchainTestsEnvironment, constants, expect, orderHashUtils, OrderStatus } from '@0x/contracts-test-utils';
import { BatchMatchedFillResults, FillResults, MatchedFillResults, Order, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils';
@@ -411,9 +412,7 @@ export class MatchOrderTester {
);
// Protocol Fee
const wethAssetData = this._deployment.assetDataEncoder
.ERC20Token(this._deployment.tokens.weth.address)
.getABIEncodedTransactionData();
const wethAssetData = encodeERC20AssetData(this._deployment.tokens.weth.address);
localBalanceStore.sendEth(
takerAddress,
this._deployment.staking.stakingProxy.address,

19
contracts/integrations/test/exchange/match_orders_maximal_fill_test.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { ExchangeRevertErrors } from '@0x/contracts-exchange';
import { ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs';
@@ -66,13 +67,9 @@ blockchainTests.resets('matchOrdersWithMaximalFill integration tests', env => {
});
// Encode the asset data.
makerAssetDataLeft = deployment.assetDataEncoder
.ERC20Token(makerAssetLeft.address)
.getABIEncodedTransactionData();
makerAssetDataRight = deployment.assetDataEncoder
.ERC20Token(makerAssetRight.address)
.getABIEncodedTransactionData();
feeAssetData = deployment.assetDataEncoder.ERC20Token(feeAsset.address).getABIEncodedTransactionData();
makerAssetDataLeft = encodeERC20AssetData(makerAssetLeft.address);
makerAssetDataRight = encodeERC20AssetData(makerAssetRight.address);
feeAssetData = encodeERC20AssetData(feeAsset.address);
// Create two market makers with compatible orders for matching.
makerLeft = new Maker({
@@ -1010,9 +1007,7 @@ blockchainTests.resets('matchOrdersWithMaximalFill integration tests', env => {
takerAssetAmount: toBaseUnitAmount(10, 18),
});
const signedOrderRight = await makerRight.signOrderAsync({
takerAssetData: deployment.assetDataEncoder
.ERC20Token(makerAssetRight.address)
.getABIEncodedTransactionData(),
takerAssetData: encodeERC20AssetData(makerAssetRight.address),
makerAssetAmount: toBaseUnitAmount(10, 18),
takerAssetAmount: toBaseUnitAmount(2, 18),
});
@@ -1046,9 +1041,7 @@ blockchainTests.resets('matchOrdersWithMaximalFill integration tests', env => {
it('should revert if the right maker asset is not equal to the left taker asset', async () => {
// Create orders to match
const signedOrderLeft = await makerLeft.signOrderAsync({
takerAssetData: deployment.assetDataEncoder
.ERC20Token(makerAssetLeft.address)
.getABIEncodedTransactionData(),
takerAssetData: encodeERC20AssetData(makerAssetLeft.address),
makerAssetAmount: toBaseUnitAmount(5, 18),
takerAssetAmount: toBaseUnitAmount(10, 18),
});

19
contracts/integrations/test/exchange/match_orders_test.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { ExchangeRevertErrors } from '@0x/contracts-exchange';
import { ReferenceFunctions as LibReferenceFunctions } from '@0x/contracts-exchange-libs';
@@ -66,13 +67,9 @@ blockchainTests.resets('matchOrders integration tests', env => {
});
// Encode the asset data.
makerAssetDataLeft = deployment.assetDataEncoder
.ERC20Token(makerAssetLeft.address)
.getABIEncodedTransactionData();
makerAssetDataRight = deployment.assetDataEncoder
.ERC20Token(makerAssetRight.address)
.getABIEncodedTransactionData();
feeAssetData = deployment.assetDataEncoder.ERC20Token(feeAsset.address).getABIEncodedTransactionData();
makerAssetDataLeft = encodeERC20AssetData(makerAssetLeft.address);
makerAssetDataRight = encodeERC20AssetData(makerAssetRight.address);
feeAssetData = encodeERC20AssetData(feeAsset.address);
// Create two market makers with compatible orders for matching.
makerLeft = new Maker({
@@ -1025,9 +1022,7 @@ blockchainTests.resets('matchOrders integration tests', env => {
takerAssetAmount: toBaseUnitAmount(10, 18),
});
const signedOrderRight = await makerRight.signOrderAsync({
takerAssetData: deployment.assetDataEncoder
.ERC20Token(makerAssetRight.address)
.getABIEncodedTransactionData(),
takerAssetData: encodeERC20AssetData(makerAssetRight.address),
makerAssetAmount: toBaseUnitAmount(10, 18),
takerAssetAmount: toBaseUnitAmount(2, 18),
});
@@ -1058,9 +1053,7 @@ blockchainTests.resets('matchOrders integration tests', env => {
it('should revert if the right maker asset is not equal to the left taker asset', async () => {
// Create orders to match
const signedOrderLeft = await makerLeft.signOrderAsync({
takerAssetData: deployment.assetDataEncoder
.ERC20Token(makerAssetLeft.address)
.getABIEncodedTransactionData(),
takerAssetData: encodeERC20AssetData(makerAssetLeft.address),
makerAssetAmount: toBaseUnitAmount(5, 18),
takerAssetAmount: toBaseUnitAmount(10, 18),
});

11
contracts/integrations/test/exchange/transaction_protocol_fee_test.ts
View File

@@ -1,5 +1,5 @@
// tslint:disable: max-file-line-count
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { exchangeDataEncoder, ExchangeRevertErrors } from '@0x/contracts-exchange';
import {
blockchainTests,
@@ -45,7 +45,6 @@ blockchainTests.resets('Transaction <> protocol fee integration tests', env => {
numErc721TokensToDeploy: 0,
numErc1155TokensToDeploy: 0,
});
const assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
const [makerToken, takerToken, makerFeeToken, takerFeeToken] = deployment.tokens.erc20;
alice = new Taker({ name: 'Alice', deployment });
@@ -61,10 +60,10 @@ blockchainTests.resets('Transaction <> protocol fee integration tests', env => {
deployment,
orderConfig: {
feeRecipientAddress: feeRecipient.address,
makerAssetData: assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData(),
takerAssetData: assetDataEncoder.ERC20Token(takerToken.address).getABIEncodedTransactionData(),
makerFeeAssetData: assetDataEncoder.ERC20Token(makerFeeToken.address).getABIEncodedTransactionData(),
takerFeeAssetData: assetDataEncoder.ERC20Token(takerFeeToken.address).getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
makerFeeAssetData: encodeERC20AssetData(makerFeeToken.address),
takerFeeAssetData: encodeERC20AssetData(takerFeeToken.address),
},
});

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

@@ -1,5 +1,5 @@
// tslint:disable: max-file-line-count
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import {
ExchangeCancelEventArgs,
ExchangeCancelUpToEventArgs,
@@ -48,7 +48,6 @@ blockchainTests.resets('Transaction integration tests', env => {
numErc721TokensToDeploy: 0,
numErc1155TokensToDeploy: 0,
});
const assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
const [makerToken, takerToken, makerFeeToken, takerFeeToken] = deployment.tokens.erc20;
takers = [new Taker({ name: 'Taker 1', deployment }), new Taker({ name: 'Taker 2', deployment })];
@@ -61,10 +60,10 @@ blockchainTests.resets('Transaction integration tests', env => {
deployment,
orderConfig: {
feeRecipientAddress: feeRecipient.address,
makerAssetData: assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData(),
takerAssetData: assetDataEncoder.ERC20Token(takerToken.address).getABIEncodedTransactionData(),
makerFeeAssetData: assetDataEncoder.ERC20Token(makerFeeToken.address).getABIEncodedTransactionData(),
takerFeeAssetData: assetDataEncoder.ERC20Token(takerFeeToken.address).getABIEncodedTransactionData(),
makerAssetData: encodeERC20AssetData(makerToken.address),
takerAssetData: encodeERC20AssetData(takerToken.address),
makerFeeAssetData: encodeERC20AssetData(makerFeeToken.address),
takerFeeAssetData: encodeERC20AssetData(takerFeeToken.address),
},
});
sender = new Actor({ name: 'Transaction sender', deployment });

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

@@ -1,4 +1,4 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { encodeERC20AssetData, encodeERC20BridgeAssetData, encodeERC721AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC721TokenContract } from '@0x/contracts-erc721';
import { ForwarderContract } from '@0x/contracts-exchange-forwarder';
import { blockchainTests, constants, getLatestBlockTimestampAsync, toBaseUnitAmount } from '@0x/contracts-test-utils';
@@ -26,7 +26,6 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
let testFactory: ForwarderTestFactory;
let forwarder: ForwarderContract;
let assetDataEncoder: IAssetDataContract;
let eth2Dai: TestEth2DaiContract;
let uniswapExchange: TestUniswapExchangeContract;
@@ -46,7 +45,6 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
let uniswapBridgeOrder: SignedOrder;
before(async () => {
assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
deployment = await DeploymentManager.deployAsync(env, {
numErc20TokensToDeploy: 2,
numErc721TokensToDeploy: 1,
@@ -63,20 +61,14 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
const [uniswapBridge] = uniswapContracts;
[, [uniswapExchange]] = uniswapContracts;
makerTokenAssetData = assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData();
makerFeeTokenAssetData = assetDataEncoder.ERC20Token(makerFeeToken.address).getABIEncodedTransactionData();
const wethAssetData = assetDataEncoder
.ERC20Token(deployment.tokens.weth.address)
.getABIEncodedTransactionData();
makerTokenAssetData = encodeERC20AssetData(makerToken.address);
makerFeeTokenAssetData = encodeERC20AssetData(makerFeeToken.address);
const wethAssetData = encodeERC20AssetData(deployment.tokens.weth.address);
const bridgeDataEncoder = AbiEncoder.create([{ name: 'fromTokenAddress', type: 'address' }]);
const bridgeData = bridgeDataEncoder.encode([deployment.tokens.weth.address]);
eth2DaiBridgeAssetData = assetDataEncoder
.ERC20Bridge(makerToken.address, eth2DaiBridge.address, bridgeData)
.getABIEncodedTransactionData();
uniswapBridgeAssetData = assetDataEncoder
.ERC20Bridge(makerToken.address, uniswapBridge.address, bridgeData)
.getABIEncodedTransactionData();
eth2DaiBridgeAssetData = encodeERC20BridgeAssetData(makerToken.address, eth2DaiBridge.address, bridgeData);
uniswapBridgeAssetData = encodeERC20BridgeAssetData(makerToken.address, uniswapBridge.address, bridgeData);
taker = new Taker({ name: 'Taker', deployment });
orderFeeRecipient = new FeeRecipient({
@@ -185,9 +177,7 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
// ERC721 order
await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFee: toBaseUnitAmount(0.01),
}),
eth2DaiBridgeOrder,
@@ -229,9 +219,7 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
// ERC721 order
await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFee: toBaseUnitAmount(0.01),
}),
uniswapBridgeOrder,
@@ -287,9 +275,7 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
// ERC721 order
await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFee: toBaseUnitAmount(0.01),
}),
eth2DaiBridgeOrder,
@@ -341,9 +327,7 @@ blockchainTests.resets('Forwarder <> ERC20Bridge integration tests', env => {
// ERC721 order
await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFee: toBaseUnitAmount(0.01),
}),
uniswapBridgeOrder,

107
contracts/integrations/test/forwarder/forwarder_test.ts
View File

@@ -1,4 +1,11 @@
import { artifacts as assetProxyArtifacts, TestStaticCallTargetContract } from '@0x/contracts-asset-proxy';
import {
artifacts as assetProxyArtifacts,
encodeERC20AssetData,
encodeERC721AssetData,
encodeMultiAssetData,
encodeStaticCallAssetData,
TestStaticCallTargetContract,
} from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { DummyERC721TokenContract } from '@0x/contracts-erc721';
import { artifacts as exchangeArtifacts, ExchangeContract } from '@0x/contracts-exchange';
@@ -64,24 +71,18 @@ blockchainTests('Forwarder integration tests', env => {
[makerToken, makerFeeToken, anotherErc20Token] = deployment.tokens.erc20;
[erc721Token] = deployment.tokens.erc721;
wethAssetData = deployment.assetDataEncoder
.ERC20Token(deployment.tokens.weth.address)
.getABIEncodedTransactionData();
makerAssetData = deployment.assetDataEncoder.ERC20Token(makerToken.address).getABIEncodedTransactionData();
staticCallSuccessAssetData = deployment.assetDataEncoder
.StaticCall(
staticCallTarget.address,
staticCallTarget.assertEvenNumber(new BigNumber(2)).getABIEncodedTransactionData(),
constants.KECCAK256_NULL,
)
.getABIEncodedTransactionData();
staticCallFailureAssetData = deployment.assetDataEncoder
.StaticCall(
staticCallTarget.address,
staticCallTarget.assertEvenNumber(new BigNumber(1)).getABIEncodedTransactionData(),
constants.KECCAK256_NULL,
)
.getABIEncodedTransactionData();
wethAssetData = encodeERC20AssetData(deployment.tokens.weth.address);
makerAssetData = encodeERC20AssetData(makerToken.address);
staticCallSuccessAssetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallTarget.assertEvenNumber(new BigNumber(2)).getABIEncodedTransactionData(),
constants.KECCAK256_NULL,
);
staticCallFailureAssetData = encodeStaticCallAssetData(
staticCallTarget.address,
staticCallTarget.assertEvenNumber(new BigNumber(1)).getABIEncodedTransactionData(),
constants.KECCAK256_NULL,
);
taker = new Taker({ name: 'Taker', deployment });
orderFeeRecipient = new FeeRecipient({
@@ -102,9 +103,7 @@ blockchainTests('Forwarder integration tests', env => {
makerAssetData,
takerAssetData: wethAssetData,
takerFee: constants.ZERO_AMOUNT,
makerFeeAssetData: deployment.assetDataEncoder
.ERC20Token(makerFeeToken.address)
.getABIEncodedTransactionData(),
makerFeeAssetData: encodeERC20AssetData(makerFeeToken.address),
takerFeeAssetData: wethAssetData,
},
});
@@ -194,9 +193,7 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketSellTestAsync(orders, 1.34);
});
it('should fail to fill an order with a percentage fee if the asset proxy is not yet approved', async () => {
const unapprovedAsset = deployment.assetDataEncoder
.ERC20Token(anotherErc20Token.address)
.getABIEncodedTransactionData();
const unapprovedAsset = encodeERC20AssetData(anotherErc20Token.address);
const order = await maker.signOrderAsync({
makerAssetData: unapprovedAsset,
takerFee: toBaseUnitAmount(2),
@@ -258,9 +255,7 @@ blockchainTests('Forwarder integration tests', env => {
});
it('should fill orders with different makerAssetData', async () => {
const firstOrder = await maker.signOrderAsync();
const secondOrderMakerAssetData = deployment.assetDataEncoder
.ERC20Token(anotherErc20Token.address)
.getABIEncodedTransactionData();
const secondOrderMakerAssetData = encodeERC20AssetData(anotherErc20Token.address);
const secondOrder = await maker.signOrderAsync({
makerAssetData: secondOrderMakerAssetData,
});
@@ -269,9 +264,7 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketSellTestAsync(orders, 1.5);
});
it('should fail to fill an order with a fee denominated in an asset other than makerAsset or WETH', async () => {
const takerFeeAssetData = deployment.assetDataEncoder
.ERC20Token(anotherErc20Token.address)
.getABIEncodedTransactionData();
const takerFeeAssetData = encodeERC20AssetData(anotherErc20Token.address);
const order = await maker.signOrderAsync({
takerFeeAssetData,
takerFee: toBaseUnitAmount(1),
@@ -337,9 +330,7 @@ blockchainTests('Forwarder integration tests', env => {
});
}
it('should fill an order with multiAsset makerAssetData', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2)], [makerAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData([new BigNumber(2)], [makerAssetData]);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});
@@ -347,9 +338,10 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketSellTestAsync([multiAssetOrder, nonMultiAssetOrder], 1.3);
});
it('should fill an order with multiAsset makerAssetData (nested StaticCall succeeds)', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2), new BigNumber(3)], [makerAssetData, staticCallSuccessAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData(
[new BigNumber(2), new BigNumber(3)],
[makerAssetData, staticCallSuccessAssetData],
);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});
@@ -357,9 +349,10 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketSellTestAsync([multiAssetOrder, nonMultiAssetOrder], 1.3);
});
it('should skip over an order with multiAsset makerAssetData where the nested StaticCall fails', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2), new BigNumber(3)], [makerAssetData, staticCallFailureAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData(
[new BigNumber(2), new BigNumber(3)],
[makerAssetData, staticCallFailureAssetData],
);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});
@@ -474,9 +467,7 @@ blockchainTests('Forwarder integration tests', env => {
});
it('should buy exactly makerAssetBuyAmount in orders with different makerAssetData', async () => {
const firstOrder = await maker.signOrderAsync();
const secondOrderMakerAssetData = deployment.assetDataEncoder
.ERC20Token(anotherErc20Token.address)
.getABIEncodedTransactionData();
const secondOrderMakerAssetData = encodeERC20AssetData(anotherErc20Token.address);
const secondOrder = await maker.signOrderAsync({
makerAssetData: secondOrderMakerAssetData,
});
@@ -525,9 +516,7 @@ blockchainTests('Forwarder integration tests', env => {
it('should buy an ERC721 asset from a single order', async () => {
const erc721Order = await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: deployment.assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFeeAssetData: wethAssetData,
});
await testFactory.marketBuyTestAsync([erc721Order], 1);
@@ -535,18 +524,14 @@ blockchainTests('Forwarder integration tests', env => {
it('should buy an ERC721 asset and pay a WETH fee', async () => {
const erc721orderWithWethFee = await maker.signOrderAsync({
makerAssetAmount: new BigNumber(1),
makerAssetData: deployment.assetDataEncoder
.ERC721Token(erc721Token.address, nftId)
.getABIEncodedTransactionData(),
makerAssetData: encodeERC721AssetData(erc721Token.address, nftId),
takerFee: toBaseUnitAmount(1),
takerFeeAssetData: wethAssetData,
});
await testFactory.marketBuyTestAsync([erc721orderWithWethFee], 1);
});
it('should fail to fill an order with a fee denominated in an asset other than makerAsset or WETH', async () => {
const takerFeeAssetData = deployment.assetDataEncoder
.ERC20Token(anotherErc20Token.address)
.getABIEncodedTransactionData();
const takerFeeAssetData = encodeERC20AssetData(anotherErc20Token.address);
const order = await maker.signOrderAsync({
takerFeeAssetData,
takerFee: toBaseUnitAmount(1),
@@ -710,9 +695,7 @@ blockchainTests('Forwarder integration tests', env => {
});
}
it('should fill an order with multiAsset makerAssetData', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2)], [makerAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData([new BigNumber(2)], [makerAssetData]);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});
@@ -720,9 +703,10 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketBuyTestAsync([multiAssetOrder, nonMultiAssetOrder], 1.3);
});
it('should fill an order with multiAsset makerAssetData (nested StaticCall succeeds)', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2), new BigNumber(3)], [makerAssetData, staticCallSuccessAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData(
[new BigNumber(2), new BigNumber(3)],
[makerAssetData, staticCallSuccessAssetData],
);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});
@@ -730,9 +714,10 @@ blockchainTests('Forwarder integration tests', env => {
await testFactory.marketBuyTestAsync([multiAssetOrder, nonMultiAssetOrder], 1.3);
});
it('should skip over an order with multiAsset makerAssetData where the nested StaticCall fails', async () => {
const multiAssetData = deployment.assetDataEncoder
.MultiAsset([new BigNumber(2), new BigNumber(3)], [makerAssetData, staticCallFailureAssetData])
.getABIEncodedTransactionData();
const multiAssetData = encodeMultiAssetData(
[new BigNumber(2), new BigNumber(3)],
[makerAssetData, staticCallFailureAssetData],
);
const multiAssetOrder = await maker.signOrderAsync({
makerAssetData: multiAssetData,
});

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

@@ -1,6 +1,6 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import { decodeERC20AssetData, decodeERC20BridgeAssetData } from '@0x/contracts-asset-proxy';
import { ForwarderContract } from '@0x/contracts-exchange-forwarder';
import { constants, expect, OrderStatus, provider } from '@0x/contracts-test-utils';
import { constants, expect, OrderStatus } from '@0x/contracts-test-utils';
import { AssetProxyId, OrderInfo, SignedOrder } from '@0x/types';
import { BigNumber, hexUtils, RevertError } from '@0x/utils';
import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
@@ -36,15 +36,14 @@ function areUnderlyingAssetsEqual(assetData1: string, assetData2: string): boole
(assetProxyId1 === AssetProxyId.ERC20 || assetProxyId1 === AssetProxyId.ERC20Bridge) &&
(assetProxyId2 === AssetProxyId.ERC20 || assetProxyId2 === AssetProxyId.ERC20Bridge)
) {
const assetDataDecoder = new IAssetDataContract(constants.NULL_ADDRESS, provider);
const tokenAddress1 =
assetProxyId1 === AssetProxyId.ERC20
? assetDataDecoder.getABIDecodedTransactionData<string>('ERC20Token', assetData1)
: assetDataDecoder.getABIDecodedTransactionData<[string]>('ERC20Bridge', assetData1)[0];
? decodeERC20AssetData(assetData1)
: decodeERC20BridgeAssetData(assetData1)[0];
const tokenAddress2 =
assetProxyId2 === AssetProxyId.ERC20
? assetDataDecoder.getABIDecodedTransactionData<string>('ERC20Token', assetData2)
: assetDataDecoder.getABIDecodedTransactionData<[string]>('ERC20Bridge', assetData2)[0];
? decodeERC20AssetData(assetData2)
: decodeERC20BridgeAssetData(assetData2)[0];
return tokenAddress2 === tokenAddress1;
} else {
return false;

2
contracts/integrations/test/framework/actors/fee_recipient.ts
View File

@@ -54,7 +54,7 @@ export function FeeRecipientMixin<TBase extends Constructor>(Base: TBase): TBase
if (this.approvalFactory === undefined) {
throw new Error('No verifying contract provided in FeeRecipient constructor');
}
return this.approvalFactory.newSignedApprovalAsync(transaction, txOrigin, signatureType);
return this.approvalFactory.newSignedApproval(transaction, txOrigin, signatureType);
}
};
}

8
contracts/integrations/test/framework/actors/maker.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { DummyERC20TokenContract } from '@0x/contracts-erc20';
import { constants, OrderFactory } from '@0x/contracts-test-utils';
import { Order, SignedOrder } from '@0x/types';
@@ -121,9 +122,7 @@ export function MakerMixin<TBase extends Constructor>(Base: TBase): TBase & Cons
makerFeeToken,
takerToken,
takerFeeToken,
].map(token =>
this.actor.deployment.assetDataEncoder.ERC20Token(token.address).getABIEncodedTransactionData(),
);
].map(token => encodeERC20AssetData(token.address));
// Maker signs the order
return this.signOrderAsync({
@@ -192,8 +191,7 @@ export function MakerMixin<TBase extends Constructor>(Base: TBase): TBase & Cons
makerFeeAssetData,
takerFeeAssetData,
] = [leftMakerToken, leftTakerToken, rightMakerToken, rightTakerToken, makerFeeToken, takerFeeToken].map(
token =>
this.actor.deployment.assetDataEncoder.ERC20Token(token.address).getABIEncodedTransactionData(),
token => encodeERC20AssetData(token.address),
);
// Construct and sign the left order

3
contracts/integrations/test/framework/assertions/stake.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import { increaseCurrentAndNextBalance, OwnerStakeByStatus, StakeStatus } from '@0x/contracts-staking';
import { expect } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils';
@@ -33,7 +34,7 @@ export function validStakeAssertion(
txData.from as string,
zrxVault.address,
amount,
deployment.assetDataEncoder.ERC20Token(deployment.tokens.zrx.address).getABIEncodedTransactionData(),
encodeERC20AssetData(deployment.tokens.zrx.address),
);
return expectedBalances;
},

3
contracts/integrations/test/framework/assertions/unstake.ts
View File

@@ -1,3 +1,4 @@
import { encodeERC20AssetData } from '@0x/contracts-asset-proxy';
import {
decreaseCurrentAndNextBalance,
OwnerStakeByStatus,
@@ -38,7 +39,7 @@ export function validUnstakeAssertion(
zrxVault.address,
txData.from as string,
amount,
deployment.assetDataEncoder.ERC20Token(deployment.tokens.zrx.address).getABIEncodedTransactionData(),
encodeERC20AssetData(deployment.tokens.zrx.address),
);
return expectedBalances;
},

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

@@ -1,6 +1,13 @@
import { IAssetDataContract } from '@0x/contracts-asset-proxy';
import {
decodeERC1155AssetData,
decodeERC20AssetData,
decodeERC20BridgeAssetData,
decodeERC721AssetData,
decodeMultiAssetData,
encodeERC20AssetData,
} from '@0x/contracts-asset-proxy';
import { ReferenceFunctions } from '@0x/contracts-exchange-libs';
import { constants, Numberish, provider } from '@0x/contracts-test-utils';
import { constants, Numberish } from '@0x/contracts-test-utils';
import { AssetProxyId, SignedOrder } from '@0x/types';
import { BigNumber, hexUtils } from '@0x/utils';
import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
@@ -12,8 +19,6 @@ import { BalanceStore } from './balance_store';
import { TokenContractsByName, TokenOwnersByName } from './types';
export class LocalBalanceStore extends BalanceStore {
private readonly _assetDataDecoder: IAssetDataContract;
/**
* Creates a new balance store based on an existing one.
* @param sourceBalanceStore Existing balance store whose values should be copied.
@@ -36,7 +41,6 @@ export class LocalBalanceStore extends BalanceStore {
tokenContractsByName: Partial<TokenContractsByName> = {},
) {
super(tokenOwnersByName, tokenContractsByName);
this._assetDataDecoder = new IAssetDataContract(constants.NULL_ADDRESS, provider);
}
/**
@@ -96,10 +100,7 @@ export class LocalBalanceStore extends BalanceStore {
const assetProxyId = hexUtils.slice(assetData, 0, 4);
switch (assetProxyId) {
case AssetProxyId.ERC20: {
const tokenAddress = this._assetDataDecoder.getABIDecodedTransactionData<string>(
'ERC20Token',
assetData,
);
const tokenAddress = decodeERC20AssetData(assetData);
_.update(this.balances.erc20, [fromAddress, tokenAddress], balance => balance.minus(amount));
_.update(this.balances.erc20, [toAddress, tokenAddress], balance =>
(balance || constants.ZERO_AMOUNT).plus(amount),
@@ -107,10 +108,7 @@ export class LocalBalanceStore extends BalanceStore {
break;
}
case AssetProxyId.ERC20Bridge: {
const [tokenAddress] = this._assetDataDecoder.getABIDecodedTransactionData<[string]>(
'ERC20Bridge',
assetData,
);
const [tokenAddress] = decodeERC20BridgeAssetData(assetData);
// The test bridge contract (TestEth2DaiBridge or TestUniswapBridge) will be the
// fromAddress in this case, and it simply mints the amount of token it needs to transfer.
_.update(this.balances.erc20, [fromAddress, tokenAddress], balance =>
@@ -122,9 +120,7 @@ export class LocalBalanceStore extends BalanceStore {
break;
}
case AssetProxyId.ERC721: {
const [tokenAddress, tokenId] = this._assetDataDecoder.getABIDecodedTransactionData<
[string, BigNumber]
>('ERC721Token', assetData);
const [tokenAddress, tokenId] = decodeERC721AssetData(assetData);
const fromTokens = _.get(this.balances.erc721, [fromAddress, tokenAddress], []);
const toTokens = _.get(this.balances.erc721, [toAddress, tokenAddress], []);
if (amount.gte(1)) {
@@ -140,9 +136,7 @@ export class LocalBalanceStore extends BalanceStore {
break;
}
case AssetProxyId.ERC1155: {
const [tokenAddress, tokenIds, tokenValues] = this._assetDataDecoder.getABIDecodedTransactionData<
[string, BigNumber[], BigNumber[]]
>('ERC1155Assets', assetData);
const [tokenAddress, tokenIds, tokenValues] = decodeERC1155AssetData(assetData);
const fromBalances = {
// tslint:disable-next-line:no-inferred-empty-object-type
fungible: _.get(this.balances.erc1155, [fromAddress, tokenAddress, 'fungible'], {}),
@@ -179,9 +173,7 @@ export class LocalBalanceStore extends BalanceStore {
break;
}
case AssetProxyId.MultiAsset: {
const [amounts, nestedAssetData] = this._assetDataDecoder.getABIDecodedTransactionData<
[BigNumber[], string[]]
>('MultiAsset', assetData);
const [amounts, nestedAssetData] = decodeMultiAssetData(assetData);
for (const [i, amt] of amounts.entries()) {
const nestedAmount = amount.times(amt);
this.transferAsset(fromAddress, toAddress, nestedAmount, nestedAssetData[i]);
@@ -255,9 +247,7 @@ export class LocalBalanceStore extends BalanceStore {
takerAddress,
deployment.staking.stakingProxy.address,
fillResults.protocolFeePaid,
deployment.assetDataEncoder
.ERC20Token(deployment.tokens.weth.address)
.getABIEncodedTransactionData(),
encodeERC20AssetData(deployment.tokens.weth.address),
);
}
}

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

@@ -4,7 +4,6 @@ import {
ERC20BridgeProxyContract,
ERC20ProxyContract,
ERC721ProxyContract,
IAssetDataContract,
MultiAssetProxyContract,
StaticCallProxyContract,
} from '@0x/contracts-asset-proxy';
@@ -204,7 +203,6 @@ export class DeploymentManager {
exchange.address,
constants.NULL_ADDRESS,
);
const assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, environment.provider);
// Construct the new instance and return it.
return new DeploymentManager(
@@ -218,7 +216,6 @@ export class DeploymentManager {
accounts,
txDefaults,
devUtils,
assetDataEncoder,
);
}
@@ -534,7 +531,6 @@ export class DeploymentManager {
public accounts: string[],
public txDefaults: Partial<TxData>,
public devUtils: DevUtilsContract,
public assetDataEncoder: IAssetDataContract,
) {}
}
// tslint:disable:max-file-line-count

14
contracts/integrations/test/fuzz_tests/exchange_signature_validation_test.ts
View File

@@ -1,6 +1,12 @@
import { ExchangeContract } from '@0x/contracts-exchange';
import { blockchainTests, constants, expect, signingUtils, transactionHashUtils } from '@0x/contracts-test-utils';
import { orderHashUtils } from '@0x/order-utils';
import {
blockchainTests,
constants,
expect,
orderHashUtils,
signingUtils,
transactionHashUtils,
} from '@0x/contracts-test-utils';
import { Order, SignatureType, ZeroExTransaction } from '@0x/types';
import { hexUtils, logUtils } from '@0x/utils';
import * as ethUtil from 'ethereumjs-util';
@@ -194,7 +200,7 @@ tests('Exchange signature validation fuzz tests', env => {
exchangeAddress: mangled.order!.exchangeAddress,
chainId: mangled.order!.chainId,
});
mangled.hash = await orderHashUtils.getOrderHashAsync(mangled.order);
mangled.hash = await orderHashUtils.getOrderHashHex(mangled.order);
break;
case 'RANDOM_TRANSACTION':
mangled.transaction = randomTransaction({
@@ -392,7 +398,7 @@ tests('Exchange signature validation fuzz tests', env => {
fields.validator || (signatureType === SignatureType.Validator ? walletContractAddress : undefined);
const signerKey = fields.signerKey || privateKeys[signer];
const order = fields.order || randomOrder({ makerAddress: signer });
const hash = fields.hash || (await orderHashUtils.getOrderHashAsync(order));
const hash = fields.hash || (await orderHashUtils.getOrderHashHex(order));
const payload =
fields.payload ||
(STRICT_LENGTH_SIGNATURE_TYPES.includes(signatureType) ? constants.NULL_BYTES : randomPayload());