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

updated unit tests

Browse Source
This commit is contained in:
David Sun
2019-11-16 11:14:34 -06:00
committed by Jacob Evans
parent e299fa27a0
commit 1135d5a971
8 changed files with 171 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/asset-swapper/src/constants.ts
View File

@@ -1,6 +1,7 @@
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import { import {
ExtensionContractType,
ForwarderExtensionContractOpts, ForwarderExtensionContractOpts,
OrderPrunerOpts, OrderPrunerOpts,
OrderPrunerPermittedFeeTypes, OrderPrunerPermittedFeeTypes,
@@ -8,7 +9,6 @@ import {
SwapQuoteGetOutputOpts, SwapQuoteGetOutputOpts,
SwapQuoteRequestOpts, SwapQuoteRequestOpts,
SwapQuoterOpts, SwapQuoterOpts,
ExtensionContractType,
} from './types'; } from './types';
const ETH_GAS_STATION_API_BASE_URL = 'https://ethgasstation.info'; const ETH_GAS_STATION_API_BASE_URL = 'https://ethgasstation.info';
@@ -18,7 +18,6 @@ const NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
const MAINNET_CHAIN_ID = 1; const MAINNET_CHAIN_ID = 1;
const ONE_SECOND_MS = 1000; const ONE_SECOND_MS = 1000;
const DEFAULT_PER_PAGE = 1000; const DEFAULT_PER_PAGE = 1000;
const PROTOCOL_FEE_MULTIPLIER = 150000;
const DEFAULT_ORDER_PRUNER_OPTS: OrderPrunerOpts = { const DEFAULT_ORDER_PRUNER_OPTS: OrderPrunerOpts = {
expiryBufferMs: 120000, // 2 minutes expiryBufferMs: 120000, // 2 minutes
@@ -68,6 +67,5 @@ export const constants = {
DEFAULT_FORWARDER_SWAP_QUOTE_EXECUTE_OPTS, DEFAULT_FORWARDER_SWAP_QUOTE_EXECUTE_OPTS,
DEFAULT_SWAP_QUOTE_REQUEST_OPTS, DEFAULT_SWAP_QUOTE_REQUEST_OPTS,
DEFAULT_PER_PAGE, DEFAULT_PER_PAGE,
PROTOCOL_FEE_MULTIPLIER,
NULL_ERC20_ASSET_DATA, NULL_ERC20_ASSET_DATA,
}; };

1
packages/asset-swapper/src/quote_consumers/forwarder_swap_quote_consumer.ts
View File

@@ -9,7 +9,6 @@ import * as _ from 'lodash';
import { constants } from '../constants'; import { constants } from '../constants';
import { import {
CalldataInfo, CalldataInfo,
ForwarderExtensionContractOpts,
ForwarderSmartContractParams, ForwarderSmartContractParams,
MarketOperation, MarketOperation,
SmartContractParamsInfo, SmartContractParamsInfo,

14
packages/asset-swapper/test/exchange_swap_quote_consumer_test.ts
View File

@@ -20,9 +20,10 @@ import {
MarketSellSwapQuote, MarketSellSwapQuote,
PrunedSignedOrder, PrunedSignedOrder,
} from '../src/types'; } from '../src/types';
import { ProtocolFeeUtils } from '../src/utils/protocol_fee_utils';
import { chaiSetup } from './utils/chai_setup'; import { chaiSetup } from './utils/chai_setup';
import { getFullyFillableSwapQuoteWithNoFees } from './utils/swap_quote'; import { getFullyFillableSwapQuoteWithNoFeesAsync } from './utils/swap_quote';
import { provider, web3Wrapper } from './utils/web3_wrapper'; import { provider, web3Wrapper } from './utils/web3_wrapper';
chaiSetup.configure(); chaiSetup.configure();
@@ -67,6 +68,8 @@ const expectMakerAndTakerBalancesAsyncFactory = (
}; };
describe('ExchangeSwapQuoteConsumer', () => { describe('ExchangeSwapQuoteConsumer', () => {
let contractWrappers: ContractWrappers;
let protocolFeeUtils: ProtocolFeeUtils;
let userAddresses: string[]; let userAddresses: string[];
let erc20MakerTokenContract: ERC20TokenContract; let erc20MakerTokenContract: ERC20TokenContract;
let erc20TakerTokenContract: ERC20TokenContract; let erc20TakerTokenContract: ERC20TokenContract;
@@ -130,6 +133,7 @@ describe('ExchangeSwapQuoteConsumer', () => {
}; };
const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)]; const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)];
orderFactory = new OrderFactory(privateKey, defaultOrderParams); orderFactory = new OrderFactory(privateKey, defaultOrderParams);
protocolFeeUtils = new ProtocolFeeUtils(contractWrappers.exchange);
expectMakerAndTakerBalancesForTakerAssetAsync = expectMakerAndTakerBalancesAsyncFactory( expectMakerAndTakerBalancesForTakerAssetAsync = expectMakerAndTakerBalancesAsyncFactory(
erc20TakerTokenContract, erc20TakerTokenContract,
makerAddress, makerAddress,
@@ -156,20 +160,22 @@ describe('ExchangeSwapQuoteConsumer', () => {
orders.push(prunedOrder as PrunedSignedOrder); orders.push(prunedOrder as PrunedSignedOrder);
} }
marketSellSwapQuote = getFullyFillableSwapQuoteWithNoFees( marketSellSwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
takerAssetData, takerAssetData,
orders, orders,
MarketOperation.Sell, MarketOperation.Sell,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
marketBuySwapQuote = getFullyFillableSwapQuoteWithNoFees( marketBuySwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
takerAssetData, takerAssetData,
orders, orders,
MarketOperation.Buy, MarketOperation.Buy,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
swapQuoteConsumer = new ExchangeSwapQuoteConsumer(provider, contractAddresses, { swapQuoteConsumer = new ExchangeSwapQuoteConsumer(provider, contractAddresses, {
@@ -212,7 +218,6 @@ describe('ExchangeSwapQuoteConsumer', () => {
); );
await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketSellSwapQuote, { await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketSellSwapQuote, {
takerAddress, takerAddress,
gasPrice: GAS_PRICE,
gasLimit: 4000000, gasLimit: 4000000,
}); });
await expectMakerAndTakerBalancesForMakerAssetAsync( await expectMakerAndTakerBalancesForMakerAssetAsync(
@@ -235,7 +240,6 @@ describe('ExchangeSwapQuoteConsumer', () => {
); );
await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketBuySwapQuote, { await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketBuySwapQuote, {
takerAddress, takerAddress,
gasPrice: GAS_PRICE,
gasLimit: 4000000, gasLimit: 4000000,
}); });
await expectMakerAndTakerBalancesForMakerAssetAsync( await expectMakerAndTakerBalancesForMakerAssetAsync(

20
packages/asset-swapper/test/forwarder_swap_quote_consumer_test.ts
View File

@@ -19,9 +19,10 @@ import {
MarketOperation, MarketOperation,
PrunedSignedOrder, PrunedSignedOrder,
} from '../src/types'; } from '../src/types';
import { ProtocolFeeUtils } from '../src/utils/protocol_fee_utils';
import { chaiSetup } from './utils/chai_setup'; import { chaiSetup } from './utils/chai_setup';
import { getFullyFillableSwapQuoteWithNoFees } from './utils/swap_quote'; import { getFullyFillableSwapQuoteWithNoFeesAsync } from './utils/swap_quote';
import { provider, web3Wrapper } from './utils/web3_wrapper'; import { provider, web3Wrapper } from './utils/web3_wrapper';
chaiSetup.configure(); chaiSetup.configure();
@@ -33,7 +34,7 @@ const ONE_ETH_IN_WEI = new BigNumber(1000000000000000000);
const TESTRPC_CHAIN_ID = devConstants.TESTRPC_CHAIN_ID; const TESTRPC_CHAIN_ID = devConstants.TESTRPC_CHAIN_ID;
const UNLIMITED_ALLOWANCE_IN_BASE_UNITS = new BigNumber(2).pow(256).minus(1); // tslint:disable-line:custom-no-magic-numbers const UNLIMITED_ALLOWANCE_IN_BASE_UNITS = new BigNumber(2).pow(256).minus(1); // tslint:disable-line:custom-no-magic-numbers
const FEE_PERCENTAGE = 0.05;
const PARTIAL_PRUNED_SIGNED_ORDERS_FEELESS: Array<Partial<PrunedSignedOrder>> = [ const PARTIAL_PRUNED_SIGNED_ORDERS_FEELESS: Array<Partial<PrunedSignedOrder>> = [
{ {
takerAssetAmount: new BigNumber(2).multipliedBy(ONE_ETH_IN_WEI), takerAssetAmount: new BigNumber(2).multipliedBy(ONE_ETH_IN_WEI),
@@ -67,7 +68,9 @@ const expectMakerAndTakerBalancesAsyncFactory = (
}; };
describe('ForwarderSwapQuoteConsumer', () => { describe('ForwarderSwapQuoteConsumer', () => {
const FEE_PERCENTAGE = 0.05; let contractWrappers: ContractWrappers;
let protocolFeeUtils: ProtocolFeeUtils;
let erc20Token: ERC20TokenContract;
let userAddresses: string[]; let userAddresses: string[];
let coinbaseAddress: string; let coinbaseAddress: string;
let makerAddress: string; let makerAddress: string;
@@ -133,6 +136,7 @@ describe('ForwarderSwapQuoteConsumer', () => {
}; };
const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)]; const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)];
orderFactory = new OrderFactory(privateKey, defaultOrderParams); orderFactory = new OrderFactory(privateKey, defaultOrderParams);
protocolFeeUtils = new ProtocolFeeUtils(contractWrappers.exchange);
expectMakerAndTakerBalancesAsync = expectMakerAndTakerBalancesAsyncFactory( expectMakerAndTakerBalancesAsync = expectMakerAndTakerBalancesAsyncFactory(
erc20TokenContract, erc20TokenContract,
makerAddress, makerAddress,
@@ -179,28 +183,31 @@ describe('ForwarderSwapQuoteConsumer', () => {
invalidOrders.push(prunedOrder as PrunedSignedOrder); invalidOrders.push(prunedOrder as PrunedSignedOrder);
} }
marketSellSwapQuote = getFullyFillableSwapQuoteWithNoFees( marketSellSwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
wethAssetData, wethAssetData,
orders, orders,
MarketOperation.Sell, MarketOperation.Sell,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
marketBuySwapQuote = getFullyFillableSwapQuoteWithNoFees( marketBuySwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
wethAssetData, wethAssetData,
orders, orders,
MarketOperation.Buy, MarketOperation.Buy,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
invalidMarketBuySwapQuote = getFullyFillableSwapQuoteWithNoFees( invalidMarketBuySwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
takerAssetData, takerAssetData,
invalidOrders, invalidOrders,
MarketOperation.Buy, MarketOperation.Buy,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
swapQuoteConsumer = new ForwarderSwapQuoteConsumer(provider, contractAddresses, { swapQuoteConsumer = new ForwarderSwapQuoteConsumer(provider, contractAddresses, {
@@ -234,7 +241,6 @@ describe('ForwarderSwapQuoteConsumer', () => {
); );
await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketBuySwapQuote, { await swapQuoteConsumer.executeSwapQuoteOrThrowAsync(marketBuySwapQuote, {
takerAddress, takerAddress,
gasPrice: GAS_PRICE,
gasLimit: 4000000, gasLimit: 4000000,
ethAmount: new BigNumber(10).multipliedBy(ONE_ETH_IN_WEI), ethAmount: new BigNumber(10).multipliedBy(ONE_ETH_IN_WEI),
}); });

165
packages/asset-swapper/test/swap_quote_calculator_test.ts
View File

@@ -1,21 +1,28 @@
import { ContractAddresses, ContractWrappers } from '@0x/contract-wrappers';
import { constants as devConstants } from '@0x/contracts-test-utils'; import { constants as devConstants } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
import * as _ from 'lodash'; import * as _ from 'lodash';
import 'mocha'; import 'mocha';
import { ProtocolFeeUtils } from '../src/utils/protocol_fee_utils';
import { swapQuoteCalculator } from '../src/utils/swap_quote_calculator'; import { swapQuoteCalculator } from '../src/utils/swap_quote_calculator';
import { chaiSetup } from './utils/chai_setup'; import { chaiSetup } from './utils/chai_setup';
import { migrateOnceAsync } from './utils/migrate';
import { testHelpers } from './utils/test_helpers'; import { testHelpers } from './utils/test_helpers';
import { testOrders } from './utils/test_orders'; import { testOrders } from './utils/test_orders';
import { baseUnitAmount } from './utils/utils'; import { baseUnitAmount } from './utils/utils';
import { provider, web3Wrapper } from './utils/web3_wrapper';
chaiSetup.configure(); chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
const GAS_PRICE = new BigNumber(devConstants.DEFAULT_GAS_PRICE); const GAS_PRICE = new BigNumber(devConstants.DEFAULT_GAS_PRICE);
const ONE_ETH_IN_WEI = new BigNumber(1000000000000000000); const ONE_ETH_IN_WEI = new BigNumber(1000000000000000000);
const TESTRPC_CHAIN_ID = 1337;
const MIXED_TEST_ORDERS = _.concat( const MIXED_TEST_ORDERS = _.concat(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
@@ -25,105 +32,130 @@ const MIXED_TEST_ORDERS = _.concat(
// tslint:disable:max-file-line-count // tslint:disable:max-file-line-count
// tslint:disable:custom-no-magic-numbers // tslint:disable:custom-no-magic-numbers
describe('swapQuoteCalculator', () => { describe('swapQuoteCalculator', () => {
let contractWrappers: ContractWrappers;
let protocolFeeUtils: ProtocolFeeUtils;
let contractAddresses: ContractAddresses;
const chainId = TESTRPC_CHAIN_ID;
before(async () => {
const config = {
chainId,
contractAddresses,
};
contractAddresses = await migrateOnceAsync();
await blockchainLifecycle.startAsync();
contractWrappers = new ContractWrappers(provider, config);
protocolFeeUtils = new ProtocolFeeUtils(contractWrappers.exchange);
});
describe('#calculateMarketSellSwapQuote', () => { describe('#calculateMarketSellSwapQuote', () => {
describe('InsufficientLiquidityError', () => { describe('InsufficientLiquidityError', () => {
it('should throw if not enough taker asset liquidity (multiple feeless orders)', () => { it('should throw if not enough taker asset liquidity (multiple feeless orders)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
baseUnitAmount(10), baseUnitAmount(10),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(9)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(9));
}); });
it('should throw if not enough taker asset liquidity (multiple feeless orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple feeless orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
baseUnitAmount(10), baseUnitAmount(10),
0.2, 0.2,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(7.5)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(7.5));
}); });
it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
baseUnitAmount(20), baseUnitAmount(20),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(15)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(15));
}); });
it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
baseUnitAmount(20), baseUnitAmount(20),
0.2, 0.2,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(12.5)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(12.5));
}); });
it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
baseUnitAmount(10), baseUnitAmount(10),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(9)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(9));
}); });
it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
baseUnitAmount(10), baseUnitAmount(10),
0.2, 0.2,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(7.5)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(7.5));
}); });
it('should throw if not enough taker asset liquidity (multiple mixed feeType orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple mixed feeType orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
MIXED_TEST_ORDERS, MIXED_TEST_ORDERS,
baseUnitAmount(40), baseUnitAmount(40),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(33)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(33));
}); });
it('should throw if not enough taker asset liquidity (multiple mixed feeTyoe orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple mixed feeTyoe orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketSellSwapQuote( await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
MIXED_TEST_ORDERS, MIXED_TEST_ORDERS,
baseUnitAmount(40), baseUnitAmount(40),
0.2, 0.2,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(27.5)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(27.5));
}); });
}); });
it('calculates a correct swapQuote with no slippage (feeless orders)', () => { it('calculates a correct swapQuote with no slippage (feeless orders)', async () => {
const assetSellAmount = baseUnitAmount(0.5); const assetSellAmount = baseUnitAmount(0.5);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEELESS[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEELESS[0]]);
@@ -144,14 +176,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (feeless orders)', () => { it('calculates a correct swapQuote with slippage (feeless orders)', async () => {
const assetSellAmount = baseUnitAmount(1); const assetSellAmount = baseUnitAmount(1);
const slippagePercentage = 0.2; const slippagePercentage = 0.2;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([ expect(swapQuote.orders).to.deep.equal([
@@ -175,14 +208,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(30, 4), protocolFeeInEthAmount: baseUnitAmount(30, 4),
}); });
}); });
it('calculates a correct swapQuote with no slippage (takerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with no slippage (takerAsset denominated fee orders)', async () => {
const assetSellAmount = baseUnitAmount(4); const assetSellAmount = baseUnitAmount(4);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET[0]]);
@@ -203,14 +237,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (takerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with slippage (takerAsset denominated fee orders)', async () => {
const assetSellAmount = baseUnitAmount(3); const assetSellAmount = baseUnitAmount(3);
const slippagePercentage = 0.5; const slippagePercentage = 0.5;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([ expect(swapQuote.orders).to.deep.equal([
@@ -234,14 +269,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(30, 4), protocolFeeInEthAmount: baseUnitAmount(30, 4),
}); });
}); });
it('calculates a correct swapQuote with no slippage (makerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with no slippage (makerAsset denominated fee orders)', async () => {
const assetSellAmount = baseUnitAmount(4); const assetSellAmount = baseUnitAmount(4);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET[0]]);
@@ -262,14 +298,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (makerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with slippage (makerAsset denominated fee orders)', async () => {
const assetSellAmount = baseUnitAmount(4); const assetSellAmount = baseUnitAmount(4);
const slippagePercentage = 0.5; const slippagePercentage = 0.5;
const swapQuote = swapQuoteCalculator.calculateMarketSellSwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
assetSellAmount, assetSellAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([ expect(swapQuote.orders).to.deep.equal([
@@ -295,105 +332,114 @@ describe('swapQuoteCalculator', () => {
}); });
}); });
}); });
describe('#calculateMarketBuySwapQuote', () => { describe('#calculateMarketBuySwapQuoteAsync', () => {
describe('InsufficientLiquidityError', () => { describe('InsufficientLiquidityError', () => {
it('should throw if not enough maker asset liquidity (multiple feeless orders)', () => { it('should throw if not enough maker asset liquidity (multiple feeless orders)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
baseUnitAmount(12), baseUnitAmount(12),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(10)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(10));
}); });
it('should throw if not enough taker asset liquidity (multiple feeless orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple feeless orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
baseUnitAmount(10), baseUnitAmount(10),
0.6, 0.6,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(6.25)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(6.25));
}); });
it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
baseUnitAmount(12), baseUnitAmount(12),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(10)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(10));
}); });
it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple takerAsset denominated fee orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
baseUnitAmount(12), baseUnitAmount(12),
0.6, 0.6,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(6.25)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(6.25));
}); });
it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
baseUnitAmount(6), baseUnitAmount(6),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(5)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(5));
}); });
it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple makerAsset denominated fee orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
baseUnitAmount(6), baseUnitAmount(6),
0.6, 0.6,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(3.125)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(3.125));
}); });
it('should throw if not enough taker asset liquidity (multiple mixed feeType orders with no slippage)', () => { it('should throw if not enough taker asset liquidity (multiple mixed feeType orders with no slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
MIXED_TEST_ORDERS, MIXED_TEST_ORDERS,
baseUnitAmount(40), baseUnitAmount(40),
0, 0,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(25)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(25));
}); });
it('should throw if not enough taker asset liquidity (multiple mixed feeTyoe orders with 20% slippage)', () => { it('should throw if not enough taker asset liquidity (multiple mixed feeTyoe orders with 20% slippage)', () => {
const errorFunction = () => { const errorFunction = async () => {
swapQuoteCalculator.calculateMarketBuySwapQuote( await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
MIXED_TEST_ORDERS, MIXED_TEST_ORDERS,
baseUnitAmount(40), baseUnitAmount(40),
0.6, 0.6,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}; };
testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(15.625)); testHelpers.expectInsufficientLiquidityError(expect, errorFunction, baseUnitAmount(15.625));
}); });
}); });
it('calculates a correct swapQuote with no slippage (feeless orders)', () => { it('calculates a correct swapQuote with no slippage (feeless orders)', async () => {
const assetBuyAmount = baseUnitAmount(3); const assetBuyAmount = baseUnitAmount(3);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEELESS[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEELESS[0]]);
@@ -414,14 +460,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (feeless orders)', () => { it('calculates a correct swapQuote with slippage (feeless orders)', async () => {
const assetBuyAmount = baseUnitAmount(5); const assetBuyAmount = baseUnitAmount(5);
const slippagePercentage = 0.5; const slippagePercentage = 0.5;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEELESS, testOrders.PRUNED_SIGNED_ORDERS_FEELESS,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([ expect(swapQuote.orders).to.deep.equal([
@@ -450,14 +497,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(30, 4), protocolFeeInEthAmount: baseUnitAmount(30, 4),
}); });
}); });
it('calculates a correct swapQuote with no slippage (takerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with no slippage (takerAsset denominated fee orders)', async () => {
const assetBuyAmount = baseUnitAmount(3); const assetBuyAmount = baseUnitAmount(3);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET[0]]);
@@ -478,14 +526,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (takerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with slippage (takerAsset denominated fee orders)', async () => {
const assetBuyAmount = baseUnitAmount(5); const assetBuyAmount = baseUnitAmount(5);
const slippagePercentage = 0.5; const slippagePercentage = 0.5;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_TAKER_ASSET,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
const fiveSixthEthInWei = new BigNumber(5) const fiveSixthEthInWei = new BigNumber(5)
.div(new BigNumber(6)) .div(new BigNumber(6))
@@ -513,14 +562,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(30, 4), protocolFeeInEthAmount: baseUnitAmount(30, 4),
}); });
}); });
it('calculates a correct swapQuote with no slippage (makerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with no slippage (makerAsset denominated fee orders)', async () => {
const assetBuyAmount = baseUnitAmount(1); const assetBuyAmount = baseUnitAmount(1);
const slippagePercentage = 0; const slippagePercentage = 0;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
// test if orders are correct // test if orders are correct
expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET[0]]); expect(swapQuote.orders).to.deep.equal([testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET[0]]);
@@ -541,14 +591,15 @@ describe('swapQuoteCalculator', () => {
protocolFeeInEthAmount: baseUnitAmount(15, 4), protocolFeeInEthAmount: baseUnitAmount(15, 4),
}); });
}); });
it('calculates a correct swapQuote with slippage (makerAsset denominated fee orders)', () => { it('calculates a correct swapQuote with slippage (makerAsset denominated fee orders)', async () => {
const assetBuyAmount = baseUnitAmount(2.5); const assetBuyAmount = baseUnitAmount(2.5);
const slippagePercentage = 0.5; const slippagePercentage = 0.5;
const swapQuote = swapQuoteCalculator.calculateMarketBuySwapQuote( const swapQuote = await swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET, testOrders.PRUNED_SIGNED_ORDERS_FEE_IN_MAKER_ASSET,
assetBuyAmount, assetBuyAmount,
slippagePercentage, slippagePercentage,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
const totalTakerAssetAmount = new BigNumber(5) const totalTakerAssetAmount = new BigNumber(5)
.div(new BigNumber(6)) .div(new BigNumber(6))

16
packages/asset-swapper/test/swap_quote_consumer_utils_test.ts
View File

@@ -11,9 +11,11 @@ import 'mocha';
import { SwapQuote, SwapQuoteConsumer } from '../src'; import { SwapQuote, SwapQuoteConsumer } from '../src';
import { constants } from '../src/constants'; import { constants } from '../src/constants';
import { ExtensionContractType, MarketOperation, PrunedSignedOrder } from '../src/types'; import { ExtensionContractType, MarketOperation, PrunedSignedOrder } from '../src/types';
import { ProtocolFeeUtils } from '../src/utils/protocol_fee_utils';
import { chaiSetup } from './utils/chai_setup'; import { chaiSetup } from './utils/chai_setup';
import { getFullyFillableSwapQuoteWithNoFees } from './utils/swap_quote'; import { getFullyFillableSwapQuoteWithNoFeesAsync } from './utils/swap_quote';
import { provider, web3Wrapper } from './utils/web3_wrapper'; import { provider, web3Wrapper } from './utils/web3_wrapper';
chaiSetup.configure(); chaiSetup.configure();
@@ -68,6 +70,8 @@ const PARTIAL_LARGE_PRUNED_SIGNED_ORDERS: Array<Partial<PrunedSignedOrder>> = [
describe('swapQuoteConsumerUtils', () => { describe('swapQuoteConsumerUtils', () => {
let wethContract: WETH9Contract; let wethContract: WETH9Contract;
let contractWrappers: ContractWrappers;
let protocolFeeUtils: ProtocolFeeUtils;
let userAddresses: string[]; let userAddresses: string[];
let makerAddress: string; let makerAddress: string;
let takerAddress: string; let takerAddress: string;
@@ -118,6 +122,7 @@ describe('swapQuoteConsumerUtils', () => {
}; };
const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)]; const privateKey = devConstants.TESTRPC_PRIVATE_KEYS[userAddresses.indexOf(makerAddress)];
orderFactory = new OrderFactory(privateKey, defaultOrderParams); orderFactory = new OrderFactory(privateKey, defaultOrderParams);
protocolFeeUtils = new ProtocolFeeUtils(contractWrappers.exchange);
forwarderOrderFactory = new OrderFactory(privateKey, defaultForwarderOrderParams); forwarderOrderFactory = new OrderFactory(privateKey, defaultForwarderOrderParams);
swapQuoteConsumer = new SwapQuoteConsumer(provider, { swapQuoteConsumer = new SwapQuoteConsumer(provider, {
@@ -173,28 +178,31 @@ describe('swapQuoteConsumerUtils', () => {
largeForwarderOrders.push(prunedOrder as PrunedSignedOrder); largeForwarderOrders.push(prunedOrder as PrunedSignedOrder);
} }
forwarderSwapQuote = getFullyFillableSwapQuoteWithNoFees( forwarderSwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
wethAssetData, wethAssetData,
forwarderOrders, forwarderOrders,
MarketOperation.Sell, MarketOperation.Sell,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
largeForwarderSwapQuote = getFullyFillableSwapQuoteWithNoFees( largeForwarderSwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
wethAssetData, wethAssetData,
largeForwarderOrders, largeForwarderOrders,
MarketOperation.Sell, MarketOperation.Sell,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
exchangeSwapQuote = getFullyFillableSwapQuoteWithNoFees( exchangeSwapQuote = await getFullyFillableSwapQuoteWithNoFeesAsync(
makerAssetData, makerAssetData,
takerAssetData, takerAssetData,
exchangeOrders, exchangeOrders,
MarketOperation.Sell, MarketOperation.Sell,
GAS_PRICE, GAS_PRICE,
protocolFeeUtils,
); );
}); });

22
packages/asset-swapper/test/utils/mocks.ts
View File

@@ -1,10 +1,17 @@
import { constants as devConstants } from '@0x/contracts-test-utils';
import { AcceptedRejectedOrders, Orderbook } from '@0x/orderbook'; import { AcceptedRejectedOrders, Orderbook } from '@0x/orderbook';
import { Web3ProviderEngine } from '@0x/subproviders'; import { Web3ProviderEngine } from '@0x/subproviders';
import { APIOrder, AssetPairsItem, SignedOrder } from '@0x/types'; import { APIOrder, AssetPairsItem, SignedOrder } from '@0x/types';
import { BigNumber } from '@0x/utils';
import * as TypeMoq from 'typemoq'; import * as TypeMoq from 'typemoq';
import { SwapQuoter } from '../../src/swap_quoter'; import { SwapQuoter } from '../../src/swap_quoter';
import { PrunedSignedOrder } from '../../src/types'; import { PrunedSignedOrder } from '../../src/types';
import { ProtocolFeeUtils } from '../../src/utils/protocol_fee_utils';
const PROTOCOL_FEE_MULTIPLIER = 150000;
// tslint:disable: max-classes-per-file
class OrderbookClass extends Orderbook { class OrderbookClass extends Orderbook {
// tslint:disable-next-line:prefer-function-over-method // tslint:disable-next-line:prefer-function-over-method
@@ -49,6 +56,21 @@ const partiallyMockedSwapQuoter = (provider: Web3ProviderEngine, orderbook: Orde
return mockedSwapQuoter; return mockedSwapQuoter;
}; };
class ProtocolFeeUtilsClass extends ProtocolFeeUtils {
// tslint:disable-next-line:prefer-function-over-method
public async getProtocolFeeMultiplierAsync(): Promise<BigNumber> {
return Promise.resolve(new BigNumber(PROTOCOL_FEE_MULTIPLIER));
}
// tslint:disable-next-line:prefer-function-over-method
public async getGasPriceEstimationOrThrowAsync(): Promise<BigNumber> {
return Promise.resolve(new BigNumber(devConstants.DEFAULT_GAS_PRICE));
}
}
export const protocolFeeUtilsMock = (): TypeMoq.IMock<ProtocolFeeUtils> => {
return TypeMoq.Mock.ofType(ProtocolFeeUtilsClass, TypeMoq.MockBehavior.Strict);
};
const mockGetPrunedSignedOrdersAsync = ( const mockGetPrunedSignedOrdersAsync = (
mockedSwapQuoter: TypeMoq.IMock<SwapQuoter>, mockedSwapQuoter: TypeMoq.IMock<SwapQuoter>,
makerAssetData: string, makerAssetData: string,

10
packages/asset-swapper/test/utils/swap_quote.ts
View File

@@ -4,15 +4,16 @@ import * as _ from 'lodash';
import { constants } from '../../src/constants'; import { constants } from '../../src/constants';
import { MarketOperation, PrunedSignedOrder, SwapQuote } from '../../src/types'; import { MarketOperation, PrunedSignedOrder, SwapQuote } from '../../src/types';
import { protocolFeeUtils } from '../../src/utils/protocol_fee_utils'; import { ProtocolFeeUtils } from '../../src/utils/protocol_fee_utils';
export const getFullyFillableSwapQuoteWithNoFees = ( export const getFullyFillableSwapQuoteWithNoFeesAsync = async (
makerAssetData: string, makerAssetData: string,
takerAssetData: string, takerAssetData: string,
orders: PrunedSignedOrder[], orders: PrunedSignedOrder[],
operation: MarketOperation, operation: MarketOperation,
gasPrice: BigNumber, gasPrice: BigNumber,
): SwapQuote => { protocolFeeUtils: ProtocolFeeUtils,
): Promise<SwapQuote> => {
const makerAssetFillAmount = _.reduce( const makerAssetFillAmount = _.reduce(
orders, orders,
(a: BigNumber, c: SignedOrder) => a.plus(c.makerAssetAmount), (a: BigNumber, c: SignedOrder) => a.plus(c.makerAssetAmount),
@@ -28,13 +29,14 @@ export const getFullyFillableSwapQuoteWithNoFees = (
feeTakerAssetAmount: constants.ZERO_AMOUNT, feeTakerAssetAmount: constants.ZERO_AMOUNT,
takerAssetAmount: totalTakerAssetAmount, takerAssetAmount: totalTakerAssetAmount,
totalTakerAssetAmount, totalTakerAssetAmount,
protocolFeeInEthAmount: protocolFeeUtils.calculateWorstCaseProtocolFee(orders, gasPrice), protocolFeeInEthAmount: await protocolFeeUtils.calculateWorstCaseProtocolFeeAsync(orders, gasPrice),
}; };
const quoteBase = { const quoteBase = {
makerAssetData, makerAssetData,
takerAssetData, takerAssetData,
orders, orders,
gasPrice,
bestCaseQuoteInfo: quoteInfo, bestCaseQuoteInfo: quoteInfo,
worstCaseQuoteInfo: quoteInfo, worstCaseQuoteInfo: quoteInfo,
}; };