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

@0x:contracts-integrations Polished up match order tester

Browse Source
This commit is contained in:
Alex Towle 2019-11-07 11:40:04 -05:00
parent 301b5e1721
commit c92ff7c622
3 changed files with 80 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,7 +18,7 @@ import {
TestStakingContract, TestStakingContract,
ZrxVaultContract, ZrxVaultContract,
} from '@0x/contracts-staking'; } from '@0x/contracts-staking';
import { BlockchainTestsEnvironment, constants } from '@0x/contracts-test-utils'; import { BlockchainTestsEnvironment, constants, TransactionHelper } from '@0x/contracts-test-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import { TxData } from 'ethereum-types'; import { TxData } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
@ -194,6 +194,17 @@ export class DeploymentManager {
const devUtils = new DevUtilsContract(constants.NULL_ADDRESS, environment.provider); const devUtils = new DevUtilsContract(constants.NULL_ADDRESS, environment.provider);
// Create a `TransactionHelper` object that uses all of the packages artifacts.
const txHelper = new TransactionHelper(environment.web3Wrapper, {
...assetProxyArtifacts,
...ERC20Artifacts,
...ERC721Artifacts,
...ERC1155Artifacts,
...exchangeArtifacts,
...stakingArtifacts,
});
// Construct the new instance and return it.
return new DeploymentManager( return new DeploymentManager(
assetProxies, assetProxies,
governor, governor,
@ -204,6 +215,7 @@ export class DeploymentManager {
accounts, accounts,
txDefaults, txDefaults,
devUtils, devUtils,
txHelper,
); );
} }
@ -494,6 +506,7 @@ export class DeploymentManager {
public accounts: string[], public accounts: string[],
public txDefaults: Partial<TxData>, public txDefaults: Partial<TxData>,
public devUtils: DevUtilsContract, public devUtils: DevUtilsContract,
public txHelper: TransactionHelper,
) {} ) {}
} }
// tslint:disable:max-file-line-count // tslint:disable:max-file-line-count

43
contracts/integrations/test/internal-integration-tests/match_orders_test.ts
View File

@ -6,7 +6,6 @@ import { blockchainTests, constants, expect } from '@0x/contracts-test-utils';
import { assetDataUtils, ExchangeRevertErrors, orderHashUtils } from '@0x/order-utils'; import { assetDataUtils, ExchangeRevertErrors, orderHashUtils } from '@0x/order-utils';
import { OrderStatus, SignedOrder } from '@0x/types'; import { OrderStatus, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as _ from 'lodash';
import { Actor } from '../actors/base'; import { Actor } from '../actors/base';
import { Maker } from '../actors/maker'; import { Maker } from '../actors/maker';
@ -15,8 +14,6 @@ import { MatchOrderTester } from '../utils/match_order_tester';
const { isRoundingErrorCeil, isRoundingErrorFloor } = LibReferenceFunctions; const { isRoundingErrorCeil, isRoundingErrorFloor } = LibReferenceFunctions;
const ZERO = constants.ZERO_AMOUNT;
blockchainTests.resets('matchOrders', env => { blockchainTests.resets('matchOrders', env => {
// The fee recipient addresses. // The fee recipient addresses.
let feeRecipientLeft: Actor; let feeRecipientLeft: Actor;
@ -2614,8 +2611,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -2656,8 +2653,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -2717,8 +2714,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO, ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(4), PROTOCOL_FEE.times(4),
@ -2776,8 +2773,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO, ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(4), PROTOCOL_FEE.times(4),
@ -2822,8 +2819,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO, ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -2898,8 +2895,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO, ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO, ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(6), PROTOCOL_FEE.times(6),
@ -2944,8 +2941,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -2999,8 +2996,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -3045,8 +3042,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO, ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(2), PROTOCOL_FEE.times(2),
@ -3124,8 +3121,8 @@ blockchainTests.resets('matchOrders', env => {
{ {
leftOrders, leftOrders,
rightOrders, rightOrders,
leftOrdersTakerAssetFilledAmounts: [ZERO, ZERO], leftOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
rightOrdersTakerAssetFilledAmounts: [ZERO, ZERO], rightOrdersTakerAssetFilledAmounts: [constants.ZERO_AMOUNT, constants.ZERO_AMOUNT],
}, },
matcher.address, matcher.address,
PROTOCOL_FEE.times(6), PROTOCOL_FEE.times(6),

121
contracts/integrations/test/utils/match_order_tester.ts
View File

@ -1,6 +1,6 @@
import { DevUtilsContract } from '@0x/contracts-dev-utils'; import { DevUtilsContract } from '@0x/contracts-dev-utils';
import { BlockchainBalanceStore, ExchangeContract, LocalBalanceStore } from '@0x/contracts-exchange'; import { BlockchainBalanceStore, ExchangeContract, LocalBalanceStore } from '@0x/contracts-exchange';
import { constants, expect, OrderStatus, TransactionHelper } from '@0x/contracts-test-utils'; import { constants, expect, OrderStatus } from '@0x/contracts-test-utils';
import { orderHashUtils } from '@0x/order-utils'; import { orderHashUtils } from '@0x/order-utils';
import { BatchMatchedFillResults, FillResults, MatchedFillResults, SignedOrder } from '@0x/types'; import { BatchMatchedFillResults, FillResults, MatchedFillResults, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
@ -9,8 +9,6 @@ import * as _ from 'lodash';
import { DeploymentManager } from './deployment_manager'; import { DeploymentManager } from './deployment_manager';
const ZERO = new BigNumber(0);
export interface FillEventArgs { export interface FillEventArgs {
orderHash: string; orderHash: string;
makerAddress: string; makerAddress: string;
@ -69,19 +67,14 @@ export interface MatchedOrders {
} }
export class MatchOrderTester { export class MatchOrderTester {
private readonly _devUtils: DevUtilsContract; /**
private readonly _deployment: DeploymentManager; * Constructs new MatchOrderTester.
private readonly _blockchainBalanceStore: BlockchainBalanceStore; */
constructor( constructor(
deployment: DeploymentManager, private readonly _deployment: DeploymentManager,
devUtils: DevUtilsContract, private readonly _devUtils: DevUtilsContract,
blockchainBalanceStore: BlockchainBalanceStore, private readonly _blockchainBalanceStore: BlockchainBalanceStore,
) { ) {}
this._deployment = deployment;
this._devUtils = devUtils;
this._blockchainBalanceStore = blockchainBalanceStore;
}
/** /**
* Performs batch order matching on a set of complementary orders and asserts results. * Performs batch order matching on a set of complementary orders and asserts results.
@ -121,14 +114,8 @@ export class MatchOrderTester {
let actualBatchMatchResults; let actualBatchMatchResults;
let transactionReceipt; let transactionReceipt;
if (withMaximalFill) { if (withMaximalFill) {
actualBatchMatchResults = await this._deployment.exchange.batchMatchOrdersWithMaximalFill.callAsync( [actualBatchMatchResults, transactionReceipt] = await this._deployment.txHelper.getResultAndReceiptAsync(
orders.leftOrders, this._deployment.exchange.batchMatchOrdersWithMaximalFill,
orders.rightOrders,
orders.leftOrders.map(order => order.signature),
orders.rightOrders.map(order => order.signature),
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
);
transactionReceipt = await this._deployment.exchange.batchMatchOrdersWithMaximalFill.awaitTransactionSuccessAsync(
orders.leftOrders, orders.leftOrders,
orders.rightOrders, orders.rightOrders,
orders.leftOrders.map(order => order.signature), orders.leftOrders.map(order => order.signature),
@ -136,14 +123,8 @@ export class MatchOrderTester {
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value }, { from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
); );
} else { } else {
actualBatchMatchResults = await this._deployment.exchange.batchMatchOrders.callAsync( [actualBatchMatchResults, transactionReceipt] = await this._deployment.txHelper.getResultAndReceiptAsync(
orders.leftOrders, this._deployment.exchange.batchMatchOrders,
orders.rightOrders,
orders.leftOrders.map(order => order.signature),
orders.rightOrders.map(order => order.signature),
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
);
transactionReceipt = await this._deployment.exchange.batchMatchOrders.awaitTransactionSuccessAsync(
orders.leftOrders, orders.leftOrders,
orders.rightOrders, orders.rightOrders,
orders.leftOrders.map(order => order.signature), orders.leftOrders.map(order => order.signature),
@ -151,6 +132,8 @@ export class MatchOrderTester {
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value }, { from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
); );
} }
// Burn the gas used to execute the transaction in the local balance store.
localBalanceStore.burnGas(takerAddress, constants.DEFAULT_GAS_PRICE * transactionReceipt.gasUsed); localBalanceStore.burnGas(takerAddress, constants.DEFAULT_GAS_PRICE * transactionReceipt.gasUsed);
// Simulate the batch order match. // Simulate the batch order match.
@ -207,14 +190,8 @@ export class MatchOrderTester {
let actualMatchResults; let actualMatchResults;
let transactionReceipt; let transactionReceipt;
if (withMaximalFill) { if (withMaximalFill) {
actualMatchResults = await this._deployment.exchange.matchOrdersWithMaximalFill.callAsync( [actualMatchResults, transactionReceipt] = await this._deployment.txHelper.getResultAndReceiptAsync(
orders.leftOrder, this._deployment.exchange.matchOrdersWithMaximalFill,
orders.rightOrder,
orders.leftOrder.signature,
orders.rightOrder.signature,
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
);
transactionReceipt = await this._deployment.exchange.matchOrdersWithMaximalFill.awaitTransactionSuccessAsync(
orders.leftOrder, orders.leftOrder,
orders.rightOrder, orders.rightOrder,
orders.leftOrder.signature, orders.leftOrder.signature,
@ -222,14 +199,8 @@ export class MatchOrderTester {
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value }, { from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
); );
} else { } else {
actualMatchResults = await this._deployment.exchange.matchOrders.callAsync( [actualMatchResults, transactionReceipt] = await this._deployment.txHelper.getResultAndReceiptAsync(
orders.leftOrder, this._deployment.exchange.matchOrders,
orders.rightOrder,
orders.leftOrder.signature,
orders.rightOrder.signature,
{ from: takerAddress, gasPrice: constants.DEFAULT_GAS_PRICE, value },
);
transactionReceipt = await this._deployment.exchange.matchOrders.awaitTransactionSuccessAsync(
orders.leftOrder, orders.leftOrder,
orders.rightOrder, orders.rightOrder,
orders.leftOrder.signature, orders.leftOrder.signature,
@ -274,34 +245,34 @@ function toFullMatchTransferAmounts(partial: Partial<MatchTransferAmounts>): Mat
leftMakerAssetSoldByLeftMakerAmount: leftMakerAssetSoldByLeftMakerAmount:
partial.leftMakerAssetSoldByLeftMakerAmount || partial.leftMakerAssetSoldByLeftMakerAmount ||
partial.leftMakerAssetBoughtByRightMakerAmount || partial.leftMakerAssetBoughtByRightMakerAmount ||
ZERO, constants.ZERO_AMOUNT,
rightMakerAssetSoldByRightMakerAmount: rightMakerAssetSoldByRightMakerAmount:
partial.rightMakerAssetSoldByRightMakerAmount || partial.rightMakerAssetSoldByRightMakerAmount ||
partial.rightMakerAssetBoughtByLeftMakerAmount || partial.rightMakerAssetBoughtByLeftMakerAmount ||
ZERO, constants.ZERO_AMOUNT,
rightMakerAssetBoughtByLeftMakerAmount: rightMakerAssetBoughtByLeftMakerAmount:
partial.rightMakerAssetBoughtByLeftMakerAmount || partial.rightMakerAssetBoughtByLeftMakerAmount ||
partial.rightMakerAssetSoldByRightMakerAmount || partial.rightMakerAssetSoldByRightMakerAmount ||
ZERO, constants.ZERO_AMOUNT,
leftMakerAssetBoughtByRightMakerAmount: partial.leftMakerAssetBoughtByRightMakerAmount || leftMakerAssetBoughtByRightMakerAmount: partial.leftMakerAssetBoughtByRightMakerAmount ||
partial.leftMakerAssetSoldByLeftMakerAmount || partial.leftMakerAssetSoldByLeftMakerAmount ||
ZERO, constants.ZERO_AMOUNT,
leftMakerFeeAssetPaidByLeftMakerAmount: leftMakerFeeAssetPaidByLeftMakerAmount:
partial.leftMakerFeeAssetPaidByLeftMakerAmount || ZERO, partial.leftMakerFeeAssetPaidByLeftMakerAmount || constants.ZERO_AMOUNT,
rightMakerFeeAssetPaidByRightMakerAmount: rightMakerFeeAssetPaidByRightMakerAmount:
partial.rightMakerFeeAssetPaidByRightMakerAmount || ZERO, partial.rightMakerFeeAssetPaidByRightMakerAmount || constants.ZERO_AMOUNT,
leftMakerAssetReceivedByTakerAmount: leftMakerAssetReceivedByTakerAmount:
partial.leftMakerAssetReceivedByTakerAmount || ZERO, partial.leftMakerAssetReceivedByTakerAmount || constants.ZERO_AMOUNT,
rightMakerAssetReceivedByTakerAmount: rightMakerAssetReceivedByTakerAmount:
partial.rightMakerAssetReceivedByTakerAmount || ZERO, partial.rightMakerAssetReceivedByTakerAmount || constants.ZERO_AMOUNT,
leftTakerFeeAssetPaidByTakerAmount: leftTakerFeeAssetPaidByTakerAmount:
partial.leftTakerFeeAssetPaidByTakerAmount || ZERO, partial.leftTakerFeeAssetPaidByTakerAmount || constants.ZERO_AMOUNT,
rightTakerFeeAssetPaidByTakerAmount: rightTakerFeeAssetPaidByTakerAmount:
partial.rightTakerFeeAssetPaidByTakerAmount || ZERO, partial.rightTakerFeeAssetPaidByTakerAmount || constants.ZERO_AMOUNT,
leftProtocolFeePaidByTakerAmount: leftProtocolFeePaidByTakerAmount:
partial.leftProtocolFeePaidByTakerAmount || ZERO, partial.leftProtocolFeePaidByTakerAmount || constants.ZERO_AMOUNT,
rightProtocolFeePaidByTakerAmount: rightProtocolFeePaidByTakerAmount:
partial.rightProtocolFeePaidByTakerAmount || ZERO, partial.rightProtocolFeePaidByTakerAmount || constants.ZERO_AMOUNT,
}; };
} }
@ -360,7 +331,7 @@ async function simulateBatchMatchOrdersAsync(
} else { } else {
batchMatchResults.filledAmounts.push([ batchMatchResults.filledAmounts.push([
orders.leftOrders[lastLeftIdx], orders.leftOrders[lastLeftIdx],
getLastMatch(batchMatchResults).orders.leftOrderTakerAssetFilledAmount || ZERO, getLastMatch(batchMatchResults).orders.leftOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT,
'left', 'left',
]); ]);
} }
@ -371,7 +342,7 @@ async function simulateBatchMatchOrdersAsync(
} else { } else {
batchMatchResults.filledAmounts.push([ batchMatchResults.filledAmounts.push([
orders.rightOrders[lastRightIdx], orders.rightOrders[lastRightIdx],
getLastMatch(batchMatchResults).orders.rightOrderTakerAssetFilledAmount || ZERO, getLastMatch(batchMatchResults).orders.rightOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT,
'right', 'right',
]); ]);
} }
@ -420,12 +391,12 @@ async function simulateBatchMatchOrdersAsync(
// here. // here.
batchMatchResults.filledAmounts.push([ batchMatchResults.filledAmounts.push([
orders.leftOrders[lastLeftIdx], orders.leftOrders[lastLeftIdx],
getLastMatch(batchMatchResults).orders.leftOrderTakerAssetFilledAmount || ZERO, getLastMatch(batchMatchResults).orders.leftOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT,
'left', 'left',
]); ]);
batchMatchResults.filledAmounts.push([ batchMatchResults.filledAmounts.push([
orders.rightOrders[lastRightIdx], orders.rightOrders[lastRightIdx],
getLastMatch(batchMatchResults).orders.rightOrderTakerAssetFilledAmount || ZERO, getLastMatch(batchMatchResults).orders.rightOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT,
'right', 'right',
]); ]);
@ -456,12 +427,12 @@ async function simulateMatchOrdersAsync(
orders: { orders: {
leftOrder: orders.leftOrder, leftOrder: orders.leftOrder,
leftOrderTakerAssetFilledAmount: leftOrderTakerAssetFilledAmount:
(orders.leftOrderTakerAssetFilledAmount || ZERO).plus( (orders.leftOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT).plus(
transferAmounts.rightMakerAssetBoughtByLeftMakerAmount, transferAmounts.rightMakerAssetBoughtByLeftMakerAmount,
), ),
rightOrder: orders.rightOrder, rightOrder: orders.rightOrder,
rightOrderTakerAssetFilledAmount: rightOrderTakerAssetFilledAmount:
(orders.rightOrderTakerAssetFilledAmount || ZERO).plus( (orders.rightOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT).plus(
transferAmounts.leftMakerAssetBoughtByRightMakerAmount, transferAmounts.leftMakerAssetBoughtByRightMakerAmount,
), ),
}, },
@ -732,8 +703,8 @@ async function assertBatchOrderStatesAsync(orders: BatchMatchedOrders, exchange:
*/ */
async function assertInitialOrderStatesAsync(orders: MatchedOrders, exchange: ExchangeContract): Promise<void> { async function assertInitialOrderStatesAsync(orders: MatchedOrders, exchange: ExchangeContract): Promise<void> {
const pairs = [ const pairs = [
[orders.leftOrder, orders.leftOrderTakerAssetFilledAmount || ZERO], [orders.leftOrder, orders.leftOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT],
[orders.rightOrder, orders.rightOrderTakerAssetFilledAmount || ZERO], [orders.rightOrder, orders.rightOrderTakerAssetFilledAmount || constants.ZERO_AMOUNT],
] as Array<[SignedOrder, BigNumber]>; ] as Array<[SignedOrder, BigNumber]>;
await Promise.all( await Promise.all(
pairs.map(async ([order, expectedFilledAmount]) => { pairs.map(async ([order, expectedFilledAmount]) => {
@ -854,20 +825,20 @@ function convertToBatchMatchResults(results: BatchMatchResults): BatchMatchedFil
const batchMatchedFillResults: BatchMatchedFillResults = { const batchMatchedFillResults: BatchMatchedFillResults = {
left: [], left: [],
right: [], right: [],
profitInLeftMakerAsset: ZERO, profitInLeftMakerAsset: constants.ZERO_AMOUNT,
profitInRightMakerAsset: ZERO, profitInRightMakerAsset: constants.ZERO_AMOUNT,
}; };
for (const match of results.matches) { for (const match of results.matches) {
const leftSpread = match.fills[0].makerAssetFilledAmount.minus(match.fills[1].takerAssetFilledAmount); const leftSpread = match.fills[0].makerAssetFilledAmount.minus(match.fills[1].takerAssetFilledAmount);
// If the left maker spread is positive for match, update the profitInLeftMakerAsset // If the left maker spread is positive for match, update the profitInLeftMakerAsset
if (leftSpread.isGreaterThan(ZERO)) { if (leftSpread.isGreaterThan(constants.ZERO_AMOUNT)) {
batchMatchedFillResults.profitInLeftMakerAsset = batchMatchedFillResults.profitInLeftMakerAsset.plus( batchMatchedFillResults.profitInLeftMakerAsset = batchMatchedFillResults.profitInLeftMakerAsset.plus(
leftSpread, leftSpread,
); );
} }
const rightSpread = match.fills[1].makerAssetFilledAmount.minus(match.fills[0].takerAssetFilledAmount); const rightSpread = match.fills[1].makerAssetFilledAmount.minus(match.fills[0].takerAssetFilledAmount);
// If the right maker spread is positive for match, update the profitInRightMakerAsset // If the right maker spread is positive for match, update the profitInRightMakerAsset
if (rightSpread.isGreaterThan(ZERO)) { if (rightSpread.isGreaterThan(constants.ZERO_AMOUNT)) {
batchMatchedFillResults.profitInRightMakerAsset = batchMatchedFillResults.profitInRightMakerAsset.plus( batchMatchedFillResults.profitInRightMakerAsset = batchMatchedFillResults.profitInRightMakerAsset.plus(
rightSpread, rightSpread,
); );
@ -891,14 +862,14 @@ function convertToBatchMatchResults(results: BatchMatchResults): BatchMatchedFil
function convertToMatchResults(result: MatchResults): MatchedFillResults { function convertToMatchResults(result: MatchResults): MatchedFillResults {
// If the left spread is negative, set it to zero // If the left spread is negative, set it to zero
let profitInLeftMakerAsset = result.fills[0].makerAssetFilledAmount.minus(result.fills[1].takerAssetFilledAmount); let profitInLeftMakerAsset = result.fills[0].makerAssetFilledAmount.minus(result.fills[1].takerAssetFilledAmount);
if (profitInLeftMakerAsset.isLessThanOrEqualTo(ZERO)) { if (profitInLeftMakerAsset.isLessThanOrEqualTo(constants.ZERO_AMOUNT)) {
profitInLeftMakerAsset = ZERO; profitInLeftMakerAsset = constants.ZERO_AMOUNT;
} }
// If the right spread is negative, set it to zero // If the right spread is negative, set it to zero
let profitInRightMakerAsset = result.fills[1].makerAssetFilledAmount.minus(result.fills[0].takerAssetFilledAmount); let profitInRightMakerAsset = result.fills[1].makerAssetFilledAmount.minus(result.fills[0].takerAssetFilledAmount);
if (profitInRightMakerAsset.isLessThanOrEqualTo(ZERO)) { if (profitInRightMakerAsset.isLessThanOrEqualTo(constants.ZERO_AMOUNT)) {
profitInRightMakerAsset = ZERO; profitInRightMakerAsset = constants.ZERO_AMOUNT;
} }
const matchedFillResults: MatchedFillResults = { const matchedFillResults: MatchedFillResults = {