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

@0x:contracts-integrations Fixed test issues

Browse Source
This commit is contained in:
Alex Towle 2019-10-28 13:48:52 -07:00
parent 91cb162662
commit ebab80cff7
1 changed files with 76 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
contracts/integrations/test/internal-integration-tests/exchange_wrapper_test.ts
View File

@ -39,12 +39,12 @@ type MarketFillArgs = [SignedOrder[], BigNumber, string[], Partial<TxData>];
// tslint:disable:no-unnecessary-type-assertion // tslint:disable:no-unnecessary-type-assertion
blockchainTests.resets('Exchange wrappers', env => { blockchainTests.resets('Exchange wrappers', env => {
let chainId: number; let chainId: number;
let makerAddress: string; let maker: string;
let takerAddress: string; let taker: string;
let feeRecipientAddress: string; let feeRecipient: string;
let maker: Maker; let makerActor: Maker;
let taker: Actor; let takerActor: Actor;
const nullFillResults: FillResults = { const nullFillResults: FillResults = {
makerAssetFilledAmount: constants.ZERO_AMOUNT, makerAssetFilledAmount: constants.ZERO_AMOUNT,
@ -63,8 +63,7 @@ blockchainTests.resets('Exchange wrappers', env => {
before(async () => { before(async () => {
chainId = await env.getChainIdAsync(); chainId = await env.getChainIdAsync();
const accounts = await env.getAccountAddressesAsync(); [feeRecipient] = await env.getAccountAddressesAsync();
const usedAddresses = ([makerAddress, takerAddress, feeRecipientAddress] = _.slice(accounts, 1, 4));
deployment = await DeploymentManager.deployAsync(env, { deployment = await DeploymentManager.deployAsync(env, {
numErc20TokensToDeploy: 3, numErc20TokensToDeploy: 3,
@ -72,39 +71,39 @@ blockchainTests.resets('Exchange wrappers', env => {
numErc1155TokensToDeploy: 0, numErc1155TokensToDeploy: 0,
}); });
maker = new Maker({ makerActor = new Maker({
name: 'market maker', name: 'market maker',
deployment, deployment,
orderConfig: { orderConfig: {
...constants.STATIC_ORDER_PARAMS, ...constants.STATIC_ORDER_PARAMS,
makerAddress,
makerAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[0].address), makerAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[0].address),
takerAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[1].address), takerAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[1].address),
makerFeeAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[2].address), makerFeeAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[2].address),
takerFeeAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[2].address), takerFeeAssetData: assetDataUtils.encodeERC20AssetData(deployment.tokens.erc20[2].address),
feeRecipientAddress, feeRecipientAddress: feeRecipient,
exchangeAddress: deployment.exchange.address, exchangeAddress: deployment.exchange.address,
chainId, chainId,
}, },
}); });
makerAddress = maker.address; maker = makerActor.address;
taker = new Actor({
takerActor = new Actor({
name: 'taker', name: 'taker',
deployment, deployment,
}); });
takerAddress = taker.address; taker = takerActor.address;
await Promise.all([ await Promise.all([
...deployment.tokens.erc20.map(token => maker.configureERC20TokenAsync(token)), ...deployment.tokens.erc20.map(token => makerActor.configureERC20TokenAsync(token)),
taker.configureERC20TokenAsync(deployment.tokens.weth, deployment.staking.stakingProxy.address), takerActor.configureERC20TokenAsync(deployment.tokens.weth, deployment.staking.stakingProxy.address),
...deployment.tokens.erc20.map(token => taker.configureERC20TokenAsync(token)), ...deployment.tokens.erc20.map(token => takerActor.configureERC20TokenAsync(token)),
]); ]);
blockchainBalances = new BlockchainBalanceStore( blockchainBalances = new BlockchainBalanceStore(
{ {
makerAddress, makerAddress: maker,
takerAddress, takerAddress: taker,
feeRecipientAddress, feeRecipientAddress: feeRecipient,
stakingProxy: deployment.staking.stakingProxy.address, stakingProxy: deployment.staking.stakingProxy.address,
}, },
{ {
@ -140,32 +139,32 @@ blockchainTests.resets('Exchange wrappers', env => {
function simulateFill(signedOrder: SignedOrder, expectedFillResults: FillResults, shouldUseWeth: boolean): void { function simulateFill(signedOrder: SignedOrder, expectedFillResults: FillResults, shouldUseWeth: boolean): void {
// taker -> maker // taker -> maker
localBalances.transferAsset( localBalances.transferAsset(
takerAddress, taker,
makerAddress, maker,
expectedFillResults.takerAssetFilledAmount, expectedFillResults.takerAssetFilledAmount,
signedOrder.takerAssetData, signedOrder.takerAssetData,
); );
// maker -> taker // maker -> taker
localBalances.transferAsset( localBalances.transferAsset(
makerAddress, maker,
takerAddress, taker,
expectedFillResults.makerAssetFilledAmount, expectedFillResults.makerAssetFilledAmount,
signedOrder.makerAssetData, signedOrder.makerAssetData,
); );
// maker -> feeRecipient // maker -> feeRecipient
localBalances.transferAsset( localBalances.transferAsset(
makerAddress, maker,
feeRecipientAddress, feeRecipient,
expectedFillResults.makerFeePaid, expectedFillResults.makerFeePaid,
signedOrder.makerFeeAssetData, signedOrder.makerFeeAssetData,
); );
// taker -> feeRecipient // taker -> feeRecipient
localBalances.transferAsset( localBalances.transferAsset(
takerAddress, taker,
feeRecipientAddress, feeRecipient,
expectedFillResults.takerFeePaid, expectedFillResults.takerFeePaid,
signedOrder.takerFeeAssetData, signedOrder.takerFeeAssetData,
); );
@ -173,17 +172,13 @@ blockchainTests.resets('Exchange wrappers', env => {
// taker -> protocol fees // taker -> protocol fees
if (shouldUseWeth) { if (shouldUseWeth) {
localBalances.transferAsset( localBalances.transferAsset(
takerAddress, taker,
deployment.staking.stakingProxy.address, deployment.staking.stakingProxy.address,
expectedFillResults.protocolFeePaid, expectedFillResults.protocolFeePaid,
wethAssetData, wethAssetData,
); );
} else { } else {
localBalances.sendEth( localBalances.sendEth(taker, deployment.staking.stakingProxy.address, expectedFillResults.protocolFeePaid);
takerAddress,
deployment.staking.stakingProxy.address,
expectedFillResults.protocolFeePaid,
);
} }
} }
@ -227,15 +222,15 @@ blockchainTests.resets('Exchange wrappers', env => {
const orderHash = orderHashUtils.getOrderHashHex(signedOrder); const orderHash = orderHashUtils.getOrderHashHex(signedOrder);
expectedFillEvents.push({ expectedFillEvents.push({
makerAddress, makerAddress: maker,
feeRecipientAddress, feeRecipientAddress: feeRecipient,
makerAssetData: signedOrder.makerAssetData, makerAssetData: signedOrder.makerAssetData,
takerAssetData: signedOrder.takerAssetData, takerAssetData: signedOrder.takerAssetData,
makerFeeAssetData: signedOrder.makerFeeAssetData, makerFeeAssetData: signedOrder.makerFeeAssetData,
takerFeeAssetData: signedOrder.takerFeeAssetData, takerFeeAssetData: signedOrder.takerFeeAssetData,
orderHash, orderHash,
takerAddress, takerAddress: taker,
senderAddress: takerAddress, senderAddress: taker,
makerAssetFilledAmount: expectedFillResults.makerAssetFilledAmount, makerAssetFilledAmount: expectedFillResults.makerAssetFilledAmount,
takerAssetFilledAmount: expectedFillResults.takerAssetFilledAmount, takerAssetFilledAmount: expectedFillResults.takerAssetFilledAmount,
makerFeePaid: expectedFillResults.makerFeePaid, makerFeePaid: expectedFillResults.makerFeePaid,
@ -245,30 +240,30 @@ blockchainTests.resets('Exchange wrappers', env => {
const transferEvents = [ const transferEvents = [
{ {
_from: takerAddress, _from: taker,
_to: makerAddress, _to: maker,
_value: expectedFillResults.takerAssetFilledAmount, _value: expectedFillResults.takerAssetFilledAmount,
}, },
{ {
_from: makerAddress, _from: maker,
_to: takerAddress, _to: taker,
_value: expectedFillResults.makerAssetFilledAmount, _value: expectedFillResults.makerAssetFilledAmount,
}, },
{ {
_from: takerAddress, _from: taker,
_to: feeRecipientAddress, _to: feeRecipient,
_value: expectedFillResults.takerFeePaid, _value: expectedFillResults.takerFeePaid,
}, },
{ {
_from: makerAddress, _from: maker,
_to: feeRecipientAddress, _to: feeRecipient,
_value: expectedFillResults.makerFeePaid, _value: expectedFillResults.makerFeePaid,
}, },
]; ];
if (shouldPayWethFees) { if (shouldPayWethFees) {
transferEvents.push({ transferEvents.push({
_from: takerAddress, _from: taker,
_to: deployment.staking.stakingProxy.address, _to: deployment.staking.stakingProxy.address,
_value: expectedFillResults.protocolFeePaid, _value: expectedFillResults.protocolFeePaid,
}); });
@ -336,7 +331,7 @@ blockchainTests.resets('Exchange wrappers', env => {
fillTestInfo: FillTestInfo[], fillTestInfo: FillTestInfo[],
): Promise<void> { ): Promise<void> {
// Burn the gas used by the taker to ensure that the expected results are accurate. // Burn the gas used by the taker to ensure that the expected results are accurate.
localBalances.burnGas(takerAddress, DeploymentManager.gasPrice.times(receipt.gasUsed)); localBalances.burnGas(taker, DeploymentManager.gasPrice.times(receipt.gasUsed));
// Update the blockchain balances balance store. // Update the blockchain balances balance store.
await blockchainBalances.updateBalancesAsync(); await blockchainBalances.updateBalancesAsync();
@ -350,7 +345,7 @@ blockchainTests.resets('Exchange wrappers', env => {
describe('fillOrKillOrder', () => { describe('fillOrKillOrder', () => {
async function testFillOrKillOrder(value: Numberish): Promise<void> { async function testFillOrKillOrder(value: Numberish): Promise<void> {
const signedOrder = await maker.signOrderAsync({ const signedOrder = await makerActor.signOrderAsync({
makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18), makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18), takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
}); });
@ -360,7 +355,7 @@ blockchainTests.resets('Exchange wrappers', env => {
signedOrder, signedOrder,
takerAssetFilledAmount, takerAssetFilledAmount,
signedOrder.signature, signedOrder.signature,
{ from: takerAddress, gasPrice: DeploymentManager.gasPrice, value }, { from: taker, gasPrice: DeploymentManager.gasPrice, value },
]; ];
const fillResults = await deployment.exchange.fillOrKillOrder.callAsync(...args); const fillResults = await deployment.exchange.fillOrKillOrder.callAsync(...args);
@ -402,7 +397,7 @@ blockchainTests.resets('Exchange wrappers', env => {
it('should revert if a signedOrder is expired', async () => { it('should revert if a signedOrder is expired', async () => {
const currentTimestamp = await getLatestBlockTimestampAsync(); const currentTimestamp = await getLatestBlockTimestampAsync();
const signedOrder = await maker.signOrderAsync({ const signedOrder = await makerActor.signOrderAsync({
expirationTimeSeconds: new BigNumber(currentTimestamp).minus(10), expirationTimeSeconds: new BigNumber(currentTimestamp).minus(10),
}); });
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrder);
@ -411,20 +406,20 @@ blockchainTests.resets('Exchange wrappers', env => {
signedOrder, signedOrder,
signedOrder.takerAssetAmount, signedOrder.takerAssetAmount,
signedOrder.signature, signedOrder.signature,
{ from: takerAddress, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee }, { from: taker, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee },
); );
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
it('should revert if entire takerAssetFillAmount not filled', async () => { it('should revert if entire takerAssetFillAmount not filled', async () => {
const signedOrder = await maker.signOrderAsync(); const signedOrder = await makerActor.signOrderAsync();
const takerAssetFillAmount = signedOrder.takerAssetAmount; const takerAssetFillAmount = signedOrder.takerAssetAmount;
await deployment.exchange.fillOrder.awaitTransactionSuccessAsync( await deployment.exchange.fillOrder.awaitTransactionSuccessAsync(
signedOrder, signedOrder,
signedOrder.takerAssetAmount.dividedToIntegerBy(2), signedOrder.takerAssetAmount.dividedToIntegerBy(2),
signedOrder.signature, signedOrder.signature,
{ from: takerAddress, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee }, { from: taker, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee },
); );
const expectedError = new ExchangeRevertErrors.IncompleteFillError( const expectedError = new ExchangeRevertErrors.IncompleteFillError(
ExchangeRevertErrors.IncompleteFillErrorCode.IncompleteFillOrder, ExchangeRevertErrors.IncompleteFillErrorCode.IncompleteFillOrder,
@ -435,7 +430,7 @@ blockchainTests.resets('Exchange wrappers', env => {
signedOrder, signedOrder,
signedOrder.takerAssetAmount, signedOrder.takerAssetAmount,
signedOrder.signature, signedOrder.signature,
{ from: takerAddress, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee }, { from: taker, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee },
); );
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
@ -444,7 +439,11 @@ blockchainTests.resets('Exchange wrappers', env => {
describe('batch functions', () => { describe('batch functions', () => {
let signedOrders: SignedOrder[]; let signedOrders: SignedOrder[];
beforeEach(async () => { beforeEach(async () => {
signedOrders = [await maker.signOrderAsync(), await maker.signOrderAsync(), await maker.signOrderAsync()]; signedOrders = [
await makerActor.signOrderAsync(),
await makerActor.signOrderAsync(),
await makerActor.signOrderAsync(),
];
}); });
describe('batchFillOrders', () => { describe('batchFillOrders', () => {
@ -480,7 +479,7 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetFillAmounts, takerAssetFillAmounts,
signedOrders.map(signedOrder => signedOrder.signature), signedOrders.map(signedOrder => signedOrder.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value, value,
}, },
@ -541,7 +540,7 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetFillAmounts, takerAssetFillAmounts,
signedOrders.map(order => order.signature), signedOrders.map(order => order.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value, value,
}, },
@ -578,7 +577,7 @@ blockchainTests.resets('Exchange wrappers', env => {
signedOrders[0], signedOrders[0],
signedOrders[0].takerAssetAmount, signedOrders[0].takerAssetAmount,
signedOrders[0].signature, signedOrders[0].signature,
{ from: takerAddress, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee }, { from: taker, gasPrice: DeploymentManager.gasPrice, value: DeploymentManager.protocolFee },
); );
const orderHashHex = orderHashUtils.getOrderHashHex(signedOrders[0]); const orderHashHex = orderHashUtils.getOrderHashHex(signedOrders[0]);
@ -588,7 +587,7 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetFillAmounts, takerAssetFillAmounts,
signedOrders.map(order => order.signature), signedOrders.map(order => order.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value: DeploymentManager.protocolFee.times(signedOrders.length), value: DeploymentManager.protocolFee.times(signedOrders.length),
}, },
@ -643,7 +642,7 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetFillAmounts, takerAssetFillAmounts,
signedOrders.map(order => order.signature), signedOrders.map(order => order.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value, value,
}, },
@ -749,7 +748,7 @@ blockchainTests.resets('Exchange wrappers', env => {
takerAssetFillAmount, takerAssetFillAmount,
signedOrders.map(order => order.signature), signedOrders.map(order => order.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value, value,
}, },
@ -806,9 +805,9 @@ blockchainTests.resets('Exchange wrappers', env => {
const fillTestInfo: FillTestInfo[] = []; const fillTestInfo: FillTestInfo[] = [];
signedOrders = [ signedOrders = [
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync({ await makerActor.signOrderAsync({
takerAssetData: differentTakerAssetData, takerAssetData: differentTakerAssetData,
}), }),
]; ];
@ -828,9 +827,9 @@ blockchainTests.resets('Exchange wrappers', env => {
const fillTestInfo: FillTestInfo[] = []; const fillTestInfo: FillTestInfo[] = [];
signedOrders = [ signedOrders = [
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync({ await makerActor.signOrderAsync({
takerAssetData: differentTakerAssetData, takerAssetData: differentTakerAssetData,
}), }),
]; ];
@ -882,7 +881,7 @@ blockchainTests.resets('Exchange wrappers', env => {
makerAssetFillAmount, makerAssetFillAmount,
signedOrders.map(order => order.signature), signedOrders.map(order => order.signature),
{ {
from: takerAddress, from: taker,
gasPrice: DeploymentManager.gasPrice, gasPrice: DeploymentManager.gasPrice,
value, value,
}, },
@ -936,9 +935,9 @@ blockchainTests.resets('Exchange wrappers', env => {
const feeToken = deployment.tokens.erc20[2]; const feeToken = deployment.tokens.erc20[2];
const differentMakerAssetData = assetDataUtils.encodeERC20AssetData(feeToken.address); const differentMakerAssetData = assetDataUtils.encodeERC20AssetData(feeToken.address);
signedOrders = [ signedOrders = [
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync({ await makerActor.signOrderAsync({
makerAssetData: differentMakerAssetData, makerAssetData: differentMakerAssetData,
}), }),
]; ];
@ -957,9 +956,9 @@ blockchainTests.resets('Exchange wrappers', env => {
const feeToken = deployment.tokens.erc20[2]; const feeToken = deployment.tokens.erc20[2];
const differentMakerAssetData = assetDataUtils.encodeERC20AssetData(feeToken.address); const differentMakerAssetData = assetDataUtils.encodeERC20AssetData(feeToken.address);
signedOrders = [ signedOrders = [
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync(), await makerActor.signOrderAsync(),
await maker.signOrderAsync({ await makerActor.signOrderAsync({
makerAssetData: differentMakerAssetData, makerAssetData: differentMakerAssetData,
}), }),
]; ];
@ -974,7 +973,7 @@ blockchainTests.resets('Exchange wrappers', env => {
it('should be able to cancel multiple signedOrders', async () => { it('should be able to cancel multiple signedOrders', async () => {
const takerAssetCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount); const takerAssetCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount);
const receipt = await deployment.exchange.batchCancelOrders.awaitTransactionSuccessAsync(signedOrders, { const receipt = await deployment.exchange.batchCancelOrders.awaitTransactionSuccessAsync(signedOrders, {
from: makerAddress, from: maker,
}); });
const expectedOrderHashes = signedOrders.map(order => orderHashUtils.getOrderHashHex(order)); const expectedOrderHashes = signedOrders.map(order => orderHashUtils.getOrderHashHex(order));
expect(receipt.logs.length).to.equal(signedOrders.length); expect(receipt.logs.length).to.equal(signedOrders.length);
@ -985,13 +984,13 @@ blockchainTests.resets('Exchange wrappers', env => {
it('should not revert if a single cancel noops', async () => { it('should not revert if a single cancel noops', async () => {
await deployment.exchange.cancelOrder.awaitTransactionSuccessAsync(signedOrders[1], { await deployment.exchange.cancelOrder.awaitTransactionSuccessAsync(signedOrders[1], {
from: makerAddress, from: maker,
}); });
const expectedOrderHashes = [signedOrders[0], ...signedOrders.slice(2)].map(order => const expectedOrderHashes = [signedOrders[0], ...signedOrders.slice(2)].map(order =>
orderHashUtils.getOrderHashHex(order), orderHashUtils.getOrderHashHex(order),
); );
const receipt = await deployment.exchange.batchCancelOrders.awaitTransactionSuccessAsync(signedOrders, { const receipt = await deployment.exchange.batchCancelOrders.awaitTransactionSuccessAsync(signedOrders, {
from: makerAddress, from: maker,
}); });
expect(receipt.logs.length).to.equal(signedOrders.length - 1); expect(receipt.logs.length).to.equal(signedOrders.length - 1);