// import {
//     blockchainTests,
//     constants,
//     expect,
//     getRandomInteger,
//     getRandomPortion,
//     randomAddress,
// } from '@0x/contracts-test-utils';
// import { SignatureType } from '@0x/protocol-utils';
// import { BigNumber, hexUtils, NULL_BYTES } from '@0x/utils';
// import * as _ from 'lodash';
//
// import { FillQuoteTransformerOrderType, LimitOrderFields } from '../../src';
// import { SamplerCallResult, SignedNativeOrder } from '../../src/types';
// import { artifacts } from '../artifacts';
// import { DummyLiquidityProviderContract, TestERC20BridgeSamplerContract } from '../wrappers';
//
// // tslint:disable: custom-no-magic-numbers
//
// const { NULL_ADDRESS } = constants;
// // HACK(dorothy-zbornak): Disabled because these tests are flakey and all this logic is moving to
// // the sampler service anyway.
// blockchainTests.skip('erc20-bridge-sampler', env => {
//     let testContract: TestERC20BridgeSamplerContract;
//     const RATE_DENOMINATOR = constants.ONE_ETHER;
//     const MIN_RATE = new BigNumber('0.01');
//     const MAX_RATE = new BigNumber('100');
//     const MIN_DECIMALS = 4;
//     const MAX_DECIMALS = 20;
//     const WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
//     const KYBER_SALT = '0x0ff3ca9d46195c39f9a12afb74207b4970349fb3cfb1e459bbf170298d326bc7';
//     const UNISWAP_BASE_SALT = '0x1d6a6a0506b0b4a554b907a4c29d9f4674e461989d9c1921feb17b26716385ab';
//     const UNISWAP_V2_SALT = '0xadc7fcb33c735913b8635927e66896b356a53a912ab2ceff929e60a04b53b3c1';
//     const INVALID_TOKEN_PAIR_ERROR = 'ERC20BridgeSampler/INVALID_TOKEN_PAIR';
//     const MAKER_TOKEN = randomAddress();
//     const TAKER_TOKEN = randomAddress();
//     const INTERMEDIATE_TOKEN = randomAddress();
//     const KYBER_RESERVE_OFFSET = new BigNumber(0);
//     let KYBER_ADDRESS = '';
//     let UNISWAP_ADDRESS = '';
//     let UNISWAP_V2_ROUTER = '';
//
//     before(async () => {
//         testContract = await TestERC20BridgeSamplerContract.deployFrom0xArtifactAsync(
//             artifacts.TestERC20BridgeSampler,
//             env.provider,
//             { ...env.txDefaults, gas: 100e6 },
//             {},
//         );
//         UNISWAP_V2_ROUTER = await testContract.uniswapV2Router().callAsync();
//         KYBER_ADDRESS = await testContract.kyber().callAsync();
//         UNISWAP_ADDRESS = await testContract.uniswap().callAsync();
//     });
//
//     function getPackedHash(...args: string[]): string {
//         return hexUtils.hash(hexUtils.concat(...args.map(a => hexUtils.toHex(a))));
//     }
//
//     function getUniswapExchangeSalt(tokenAddress: string): string {
//         return getPackedHash(UNISWAP_BASE_SALT, tokenAddress);
//     }
//
//     function getDeterministicRate(salt: string, sellToken: string, buyToken: string): BigNumber {
//         const hash = getPackedHash(salt, sellToken, buyToken);
//         const _minRate = RATE_DENOMINATOR.times(MIN_RATE);
//         const _maxRate = RATE_DENOMINATOR.times(MAX_RATE);
//         return new BigNumber(hash)
//             .mod(_maxRate.minus(_minRate))
//             .plus(_minRate)
//             .div(RATE_DENOMINATOR);
//     }
//
//     function getDeterministicTokenDecimals(token: string): number {
//         if (token === WETH_ADDRESS) {
//             return 18;
//         }
//         // HACK(dorothy-zbornak): Linter will complain about the addition not being
//         // between two numbers, even though they are.
//         // tslint:disable-next-line restrict-plus-operands
//         return new BigNumber(getPackedHash(token)).mod(MAX_DECIMALS - MIN_DECIMALS).toNumber() + MIN_DECIMALS;
//     }
//
//     function getDeterministicSellQuote(
//         salt: string,
//         sellToken: string,
//         buyToken: string,
//         sellAmount: BigNumber,
//     ): BigNumber {
//         const sellBase = new BigNumber(10).pow(getDeterministicTokenDecimals(sellToken));
//         const buyBase = new BigNumber(10).pow(getDeterministicTokenDecimals(buyToken));
//         const rate = getDeterministicRate(salt, sellToken, buyToken);
//         return sellAmount
//             .times(rate)
//             .times(buyBase)
//             .dividedToIntegerBy(sellBase);
//     }
//
//     function getDeterministicBuyQuote(
//         salt: string,
//         sellToken: string,
//         buyToken: string,
//         buyAmount: BigNumber,
//     ): BigNumber {
//         const sellBase = new BigNumber(10).pow(getDeterministicTokenDecimals(sellToken));
//         const buyBase = new BigNumber(10).pow(getDeterministicTokenDecimals(buyToken));
//         const rate = getDeterministicRate(salt, sellToken, buyToken);
//         return buyAmount
//             .times(sellBase)
//             .dividedToIntegerBy(rate)
//             .dividedToIntegerBy(buyBase);
//     }
//
//     function areAddressesEqual(a: string, b: string): boolean {
//         return a.toLowerCase() === b.toLowerCase();
//     }
//
//     function getDeterministicUniswapSellQuote(sellToken: string, buyToken: string, sellAmount: BigNumber): BigNumber {
//         if (areAddressesEqual(buyToken, WETH_ADDRESS)) {
//             return getDeterministicSellQuote(getUniswapExchangeSalt(sellToken), sellToken, WETH_ADDRESS, sellAmount);
//         }
//         if (areAddressesEqual(sellToken, WETH_ADDRESS)) {
//             return getDeterministicSellQuote(getUniswapExchangeSalt(buyToken), buyToken, WETH_ADDRESS, sellAmount);
//         }
//         const ethBought = getDeterministicSellQuote(
//             getUniswapExchangeSalt(sellToken),
//             sellToken,
//             WETH_ADDRESS,
//             sellAmount,
//         );
//         return getDeterministicSellQuote(getUniswapExchangeSalt(buyToken), buyToken, WETH_ADDRESS, ethBought);
//     }
//
//     function getDeterministicUniswapBuyQuote(sellToken: string, buyToken: string, buyAmount: BigNumber): BigNumber {
//         if (areAddressesEqual(buyToken, WETH_ADDRESS)) {
//             return getDeterministicBuyQuote(getUniswapExchangeSalt(sellToken), WETH_ADDRESS, sellToken, buyAmount);
//         }
//         if (areAddressesEqual(sellToken, WETH_ADDRESS)) {
//             return getDeterministicBuyQuote(getUniswapExchangeSalt(buyToken), WETH_ADDRESS, buyToken, buyAmount);
//         }
//         const ethSold = getDeterministicBuyQuote(getUniswapExchangeSalt(buyToken), WETH_ADDRESS, buyToken, buyAmount);
//         return getDeterministicBuyQuote(getUniswapExchangeSalt(sellToken), WETH_ADDRESS, sellToken, ethSold);
//     }
//
//     function getDeterministicSellQuotes(
//         sellToken: string,
//         buyToken: string,
//         sources: string[],
//         sampleAmounts: BigNumber[],
//     ): BigNumber[][] {
//         const quotes: BigNumber[][] = [];
//         for (const source of sources) {
//             const sampleOutputs = [];
//             for (const amount of sampleAmounts) {
//                 if (source === 'Kyber') {
//                     sampleOutputs.push(getDeterministicSellQuote(KYBER_SALT, sellToken, buyToken, amount));
//                 } else if (source === 'Uniswap') {
//                     sampleOutputs.push(getDeterministicUniswapSellQuote(sellToken, buyToken, amount));
//                 }
//             }
//             quotes.push(sampleOutputs);
//         }
//         return quotes;
//     }
//
//     function getDeterministicBuyQuotes(
//         sellToken: string,
//         buyToken: string,
//         sources: string[],
//         sampleAmounts: BigNumber[],
//     ): BigNumber[][] {
//         const quotes: BigNumber[][] = [];
//         for (const source of sources) {
//             const sampleOutputs = [];
//             for (const amount of sampleAmounts) {
//                 if (source === 'Kyber') {
//                     sampleOutputs.push(getDeterministicBuyQuote(KYBER_SALT, sellToken, buyToken, amount));
//                 } else if (source === 'Uniswap') {
//                     sampleOutputs.push(getDeterministicUniswapBuyQuote(sellToken, buyToken, amount));
//                 }
//             }
//             quotes.push(sampleOutputs);
//         }
//         return quotes;
//     }
//
//     function getDeterministicUniswapV2SellQuote(path: string[], sellAmount: BigNumber): BigNumber {
//         let bought = sellAmount;
//         for (let i = 0; i < path.length - 1; ++i) {
//             bought = getDeterministicSellQuote(UNISWAP_V2_SALT, path[i], path[i + 1], bought);
//         }
//         return bought;
//     }
//
//     function getDeterministicUniswapV2BuyQuote(path: string[], buyAmount: BigNumber): BigNumber {
//         let sold = buyAmount;
//         for (let i = path.length - 1; i > 0; --i) {
//             sold = getDeterministicBuyQuote(UNISWAP_V2_SALT, path[i - 1], path[i], sold);
//         }
//         return sold;
//     }
//
//     function getDeterministicFillableTakerAssetAmount(order: SignedNativeOrder): BigNumber {
//         const hash = getPackedHash(hexUtils.leftPad(order.order.salt));
//         return new BigNumber(hash).mod(order.order.takerAmount);
//     }
//
//     function getDeterministicFillableMakerAssetAmount(order: SignedNativeOrder): BigNumber {
//         const takerAmount = getDeterministicFillableTakerAssetAmount(order);
//         return order.order.makerAmount
//             .times(takerAmount)
//             .div(order.order.takerAmount)
//             .integerValue(BigNumber.ROUND_UP);
//     }
//
//     function getSampleAmounts(tokenAddress: string, count?: number): BigNumber[] {
//         const tokenDecimals = getDeterministicTokenDecimals(tokenAddress);
//         const _upperLimit = getRandomPortion(getRandomInteger(1000, 50000).times(10 ** tokenDecimals));
//         const _count = count || _.random(1, 16);
//         const d = _upperLimit.div(_count);
//         return _.times(_count, i => d.times((i + 1) / _count).integerValue());
//     }
//
//     function createOrder(makerToken: string, takerToken: string): SignedNativeOrder {
//         return {
//             order: {
//                 chainId: 1337,
//                 verifyingContract: randomAddress(),
//                 maker: randomAddress(),
//                 taker: randomAddress(),
//                 pool: NULL_BYTES,
//                 sender: NULL_ADDRESS,
//                 feeRecipient: randomAddress(),
//                 makerAmount: getRandomInteger(1, 1e18),
//                 takerAmount: getRandomInteger(1, 1e18),
//                 takerTokenFeeAmount: getRandomInteger(1, 1e18),
//                 makerToken,
//                 takerToken,
//                 salt: new BigNumber(hexUtils.random()),
//                 expiry: getRandomInteger(0, 2 ** 32),
//             },
//             signature: { v: 1, r: NULL_BYTES, s: NULL_BYTES, signatureType: SignatureType.EthSign },
//             type: FillQuoteTransformerOrderType.Limit,
//         };
//     }
//
//     function createOrders(makerToken: string, takerToken: string, count?: number): SignedNativeOrder[] {
//         return _.times(count || _.random(1, 16), () => createOrder(makerToken, takerToken));
//     }
//
//     async function enableFailTriggerAsync(): Promise<void> {
//         await testContract.enableFailTrigger().awaitTransactionSuccessAsync({ value: 1 });
//     }
//
//     function expectQuotesWithinRange(
//         quotes: BigNumber[],
//         expectedQuotes: BigNumber[],
//         maxSlippage: BigNumber | number,
//     ): void {
//         quotes.forEach((_q, i) => {
//             // If we're within 1 base unit of a low decimal token
//             // then that's as good as we're going to get (and slippage is "high")
//             if (
//                 expectedQuotes[i].isZero() ||
//                 BigNumber.max(expectedQuotes[i], quotes[i])
//                     .minus(BigNumber.min(expectedQuotes[i], quotes[i]))
//                     .eq(1)
//             ) {
//                 return;
//             }
//             const slippage = quotes[i]
//                 .dividedBy(expectedQuotes[i])
//                 .minus(1)
//                 .decimalPlaces(4);
//             expect(slippage, `quote[${i}]: ${slippage} ${quotes[i]} ${expectedQuotes[i]}`).to.be.bignumber.gte(0);
//             expect(slippage, `quote[${i}] ${slippage} ${quotes[i]} ${expectedQuotes[i]}`).to.be.bignumber.lte(
//                 new BigNumber(maxSlippage),
//             );
//         });
//     }
//
//     describe('getOrderFillableTakerAssetAmounts()', () => {
//         it('returns the expected amount for each order', async () => {
//             const orders = createOrders(MAKER_TOKEN, TAKER_TOKEN);
//             const expected = orders.map(getDeterministicFillableTakerAssetAmount);
//             const actual = await testContract
//                 .getLimitOrderFillableTakerAssetAmounts(
//                     // tslint:disable-next-line:no-unnecessary-type-assertion
//                     orders.map(o => o.order as LimitOrderFields),
//                     orders.map(o => o.signature),
//                     NULL_ADDRESS,
//                 )
//                 .callAsync();
//             expect(actual).to.deep.eq(expected);
//         });
//
//         it('returns empty for no orders', async () => {
//             const actual = await testContract.getLimitOrderFillableTakerAssetAmounts([], [], NULL_ADDRESS).callAsync();
//             expect(actual).to.deep.eq([]);
//         });
//     });
//
//     describe('getOrderFillableMakerAssetAmounts()', () => {
//         it('returns the expected amount for each order', async () => {
//             const orders = createOrders(MAKER_TOKEN, TAKER_TOKEN);
//             const expected = orders.map(getDeterministicFillableMakerAssetAmount);
//             const actual = await testContract
//                 .getLimitOrderFillableMakerAssetAmounts(
//                     // tslint:disable-next-line:no-unnecessary-type-assertion
//                     orders.map(o => o.order as LimitOrderFields),
//                     orders.map(o => o.signature),
//                     NULL_ADDRESS,
//                 )
//                 .callAsync();
//             expect(actual).to.deep.eq(expected);
//         });
//
//         it('returns empty for no orders', async () => {
//             const actual = await testContract.getLimitOrderFillableMakerAssetAmounts([], [], NULL_ADDRESS).callAsync();
//             expect(actual).to.deep.eq([]);
//         });
//     });
//
//     blockchainTests.resets('sampleSellsFromKyberNetwork()', () => {
//         let kyberOpts = {
//             hintHandler: NULL_ADDRESS,
//             networkProxy: NULL_ADDRESS,
//             weth: WETH_ADDRESS,
//             reserveOffset: KYBER_RESERVE_OFFSET,
//             hint: NULL_BYTES,
//         };
//         before(async () => {
//             await testContract.createTokenExchanges([MAKER_TOKEN, TAKER_TOKEN]).awaitTransactionSuccessAsync();
//             kyberOpts = {
//                 ...kyberOpts,
//                 hintHandler: KYBER_ADDRESS,
//                 networkProxy: KYBER_ADDRESS,
//             };
//         });
//
//         it('throws if tokens are the same', async () => {
//             const tx = testContract.sampleSellsFromKyberNetwork(kyberOpts, MAKER_TOKEN, MAKER_TOKEN, []).callAsync();
//             return expect(tx).to.revertWith(INVALID_TOKEN_PAIR_ERROR);
//         });
//
//         it('can return no quotes', async () => {
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> ETH', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(TAKER_TOKEN, WETH_ADDRESS, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, TAKER_TOKEN, WETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(TAKER_TOKEN, MAKER_TOKEN, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> ETH fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, TAKER_TOKEN, WETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote ETH -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(WETH_ADDRESS, TAKER_TOKEN, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, WETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if ETH -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleSellsFromKyberNetwork(kyberOpts, WETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     blockchainTests.resets('sampleBuysFromKyberNetwork()', () => {
//         let kyberOpts = {
//             hintHandler: NULL_ADDRESS,
//             networkProxy: NULL_ADDRESS,
//             weth: WETH_ADDRESS,
//             reserveOffset: KYBER_RESERVE_OFFSET,
//             hint: NULL_BYTES,
//         };
//         const ACCEPTABLE_SLIPPAGE = 0.0005;
//         before(async () => {
//             await testContract.createTokenExchanges([MAKER_TOKEN, TAKER_TOKEN]).awaitTransactionSuccessAsync();
//             kyberOpts = {
//                 ...kyberOpts,
//                 hintHandler: KYBER_ADDRESS,
//                 networkProxy: KYBER_ADDRESS,
//             };
//         });
//
//         it('throws if tokens are the same', async () => {
//             const tx = testContract.sampleBuysFromKyberNetwork(kyberOpts, MAKER_TOKEN, MAKER_TOKEN, []).callAsync();
//             return expect(tx).to.revertWith(INVALID_TOKEN_PAIR_ERROR);
//         });
//
//         it('can return no quotes', async () => {
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(TAKER_TOKEN, MAKER_TOKEN, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expectQuotesWithinRange(quotes, expectedQuotes, ACCEPTABLE_SLIPPAGE);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> ETH', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(TAKER_TOKEN, WETH_ADDRESS, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, TAKER_TOKEN, WETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expectQuotesWithinRange(quotes, expectedQuotes, ACCEPTABLE_SLIPPAGE);
//         });
//
//         it('returns zero if token -> ETH fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, TAKER_TOKEN, WETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote ETH -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(WETH_ADDRESS, TAKER_TOKEN, ['Kyber'], sampleAmounts);
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, WETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expectQuotesWithinRange(quotes, expectedQuotes, ACCEPTABLE_SLIPPAGE);
//         });
//
//         it('returns zero if ETH -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const [, , quotes] = await testContract
//                 .sampleBuysFromKyberNetwork(kyberOpts, WETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     blockchainTests.resets('sampleSellsFromUniswap()', () => {
//         const UNISWAP_ETH_ADDRESS = NULL_ADDRESS;
//         before(async () => {
//             await testContract.createTokenExchanges([MAKER_TOKEN, TAKER_TOKEN]).awaitTransactionSuccessAsync();
//         });
//
//         it('throws if tokens are the same', async () => {
//             const tx = testContract.sampleSellsFromUniswap(UNISWAP_ADDRESS, MAKER_TOKEN, MAKER_TOKEN, []).callAsync();
//             return expect(tx).to.revertWith(INVALID_TOKEN_PAIR_ERROR);
//         });
//
//         it('can return no quotes', async () => {
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(TAKER_TOKEN, MAKER_TOKEN, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> ETH', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(TAKER_TOKEN, WETH_ADDRESS, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, UNISWAP_ETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> ETH fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, UNISWAP_ETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote ETH -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicSellQuotes(WETH_ADDRESS, TAKER_TOKEN, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, UNISWAP_ETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if ETH -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, UNISWAP_ETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if no exchange exists for the maker token', async () => {
//             const nonExistantToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, nonExistantToken, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if no exchange exists for the taker token', async () => {
//             const nonExistantToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(nonExistantToken);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             const quotes = await testContract
//                 .sampleSellsFromUniswap(UNISWAP_ADDRESS, nonExistantToken, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     blockchainTests.resets('sampleBuysFromUniswap()', () => {
//         const UNISWAP_ETH_ADDRESS = NULL_ADDRESS;
//         before(async () => {
//             await testContract.createTokenExchanges([MAKER_TOKEN, TAKER_TOKEN]).awaitTransactionSuccessAsync();
//         });
//
//         it('throws if tokens are the same', async () => {
//             const tx = testContract.sampleBuysFromUniswap(UNISWAP_ADDRESS, MAKER_TOKEN, MAKER_TOKEN, []).callAsync();
//             return expect(tx).to.revertWith(INVALID_TOKEN_PAIR_ERROR);
//         });
//
//         it('can return no quotes', async () => {
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(TAKER_TOKEN, MAKER_TOKEN, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> ETH', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(TAKER_TOKEN, WETH_ADDRESS, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, UNISWAP_ETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> ETH fails', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, UNISWAP_ETH_ADDRESS, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote ETH -> token', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const [expectedQuotes] = getDeterministicBuyQuotes(WETH_ADDRESS, TAKER_TOKEN, ['Uniswap'], sampleAmounts);
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, UNISWAP_ETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if ETH -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, UNISWAP_ETH_ADDRESS, TAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if no exchange exists for the maker token', async () => {
//             const nonExistantToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(nonExistantToken);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, TAKER_TOKEN, nonExistantToken, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if no exchange exists for the taker token', async () => {
//             const nonExistantToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             const quotes = await testContract
//                 .sampleBuysFromUniswap(UNISWAP_ADDRESS, nonExistantToken, MAKER_TOKEN, sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     describe('liquidity provider', () => {
//         const xAsset = randomAddress();
//         const yAsset = randomAddress();
//         const sampleAmounts = getSampleAmounts(yAsset);
//         let liquidityProvider: DummyLiquidityProviderContract;
//
//         before(async () => {
//             liquidityProvider = await DummyLiquidityProviderContract.deployFrom0xArtifactAsync(
//                 artifacts.DummyLiquidityProvider,
//                 env.provider,
//                 env.txDefaults,
//                 {},
//             );
//         });
//
//         it('should be able to query sells from the liquidity provider', async () => {
//             const quotes = await testContract
//                 .sampleSellsFromLiquidityProvider(liquidityProvider.address, yAsset, xAsset, sampleAmounts)
//                 .callAsync();
//             quotes.forEach((value, idx) => {
//                 expect(value).is.bignumber.eql(sampleAmounts[idx].minus(1));
//             });
//         });
//
//         it('should be able to query buys from the liquidity provider', async () => {
//             const quotes = await testContract
//                 .sampleBuysFromLiquidityProvider(liquidityProvider.address, yAsset, xAsset, sampleAmounts)
//                 .callAsync();
//             quotes.forEach((value, idx) => {
//                 expect(value).is.bignumber.eql(sampleAmounts[idx].plus(1));
//             });
//         });
//
//         it('should just return zeros if the liquidity provider does not exist', async () => {
//             const quotes = await testContract
//                 .sampleBuysFromLiquidityProvider(randomAddress(), yAsset, xAsset, sampleAmounts)
//                 .callAsync();
//             quotes.forEach(value => {
//                 expect(value).is.bignumber.eql(constants.ZERO_AMOUNT);
//             });
//         });
//     });
//
//     blockchainTests.resets('sampleSellsFromUniswapV2()', () => {
//         function predictSellQuotes(path: string[], sellAmounts: BigNumber[]): BigNumber[] {
//             return sellAmounts.map(a => getDeterministicUniswapV2SellQuote(path, a));
//         }
//
//         it('can return no quotes', async () => {
//             const quotes = await testContract
//                 .sampleSellsFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = predictSellQuotes([TAKER_TOKEN, MAKER_TOKEN], sampleAmounts);
//             const quotes = await testContract
//                 .sampleSellsFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleSellsFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> token -> token', async () => {
//             const intermediateToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(TAKER_TOKEN);
//             const expectedQuotes = predictSellQuotes([TAKER_TOKEN, intermediateToken, MAKER_TOKEN], sampleAmounts);
//             const quotes = await testContract
//                 .sampleSellsFromUniswapV2(
//                     UNISWAP_V2_ROUTER,
//                     [TAKER_TOKEN, intermediateToken, MAKER_TOKEN],
//                     sampleAmounts,
//                 )
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     blockchainTests.resets('sampleBuysFromUniswapV2()', () => {
//         function predictBuyQuotes(path: string[], buyAmounts: BigNumber[]): BigNumber[] {
//             return buyAmounts.map(a => getDeterministicUniswapV2BuyQuote(path, a));
//         }
//
//         it('can return no quotes', async () => {
//             const quotes = await testContract
//                 .sampleBuysFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], [])
//                 .callAsync();
//             expect(quotes).to.deep.eq([]);
//         });
//
//         it('can quote token -> token', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = predictBuyQuotes([TAKER_TOKEN, MAKER_TOKEN], sampleAmounts);
//             const quotes = await testContract
//                 .sampleBuysFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('returns zero if token -> token fails', async () => {
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = _.times(sampleAmounts.length, () => constants.ZERO_AMOUNT);
//             await enableFailTriggerAsync();
//             const quotes = await testContract
//                 .sampleBuysFromUniswapV2(UNISWAP_V2_ROUTER, [TAKER_TOKEN, MAKER_TOKEN], sampleAmounts)
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//
//         it('can quote token -> token -> token', async () => {
//             const intermediateToken = randomAddress();
//             const sampleAmounts = getSampleAmounts(MAKER_TOKEN);
//             const expectedQuotes = predictBuyQuotes([TAKER_TOKEN, intermediateToken, MAKER_TOKEN], sampleAmounts);
//             const quotes = await testContract
//                 .sampleBuysFromUniswapV2(
//                     UNISWAP_V2_ROUTER,
//                     [TAKER_TOKEN, intermediateToken, MAKER_TOKEN],
//                     sampleAmounts,
//                 )
//                 .callAsync();
//             expect(quotes).to.deep.eq(expectedQuotes);
//         });
//     });
//
//     describe('batchCall()', () => {
//         it('can call one function', async () => {
//             const orders = createOrders(MAKER_TOKEN, TAKER_TOKEN);
//             const expected = orders.map(getDeterministicFillableTakerAssetAmount);
//             const calls = [
//                 testContract
//                     .getLimitOrderFillableTakerAssetAmounts(
//                         // tslint:disable-next-line:no-unnecessary-type-assertion
//                         orders.map(o => o.order as LimitOrderFields),
//                         orders.map(o => o.signature),
//                         NULL_ADDRESS,
//                     )
//                     .getABIEncodedTransactionData(),
//             ];
//             const r = await testContract.batchCall(calls).callAsync();
//             expect(r).to.be.length(1);
//             const actual = testContract.getABIDecodedReturnData<BigNumber[]>(
//                 'getLimitOrderFillableTakerAssetAmounts',
//                 r[0].data,
//             );
//             expect(actual).to.deep.eq(expected);
//         });
//
//         it('can call two functions', async () => {
//             const numOrders = _.random(1, 10);
//             const orders = _.times(2, () => createOrders(MAKER_TOKEN, TAKER_TOKEN, numOrders));
//             const expecteds = [
//                 orders[0].map(getDeterministicFillableTakerAssetAmount),
//                 orders[1].map(getDeterministicFillableMakerAssetAmount),
//             ];
//             const calls = [
//                 testContract
//                     .getLimitOrderFillableTakerAssetAmounts(
//                         // tslint:disable-next-line:no-unnecessary-type-assertion
//                         orders[0].map(o => o.order as LimitOrderFields),
//                         orders[0].map(o => o.signature),
//                         NULL_ADDRESS,
//                     )
//                     .getABIEncodedTransactionData(),
//                 testContract
//                     .getLimitOrderFillableMakerAssetAmounts(
//                         // tslint:disable-next-line:no-unnecessary-type-assertion
//                         orders[1].map(o => o.order as LimitOrderFields),
//                         orders[1].map(o => o.signature),
//                         NULL_ADDRESS,
//                     )
//                     .getABIEncodedTransactionData(),
//             ];
//             const r = await testContract.batchCall(calls).callAsync();
//             expect(r).to.be.length(2);
//             expect(
//                 testContract.getABIDecodedReturnData('getLimitOrderFillableTakerAssetAmounts', r[0].data),
//             ).to.deep.eq(expecteds[0]);
//             expect(
//                 testContract.getABIDecodedReturnData('getLimitOrderFillableMakerAssetAmounts', r[1].data),
//             ).to.deep.eq(expecteds[1]);
//         });
//
//         it('can make recursive calls', async () => {
//             const numOrders = _.random(1, 10);
//             const orders = createOrders(MAKER_TOKEN, TAKER_TOKEN, numOrders);
//             const expected = orders.map(getDeterministicFillableTakerAssetAmount);
//             let r = await testContract
//                 .batchCall([
//                     testContract
//                         .batchCall([
//                             testContract
//                                 .getLimitOrderFillableTakerAssetAmounts(
//                                     // tslint:disable-next-line:no-unnecessary-type-assertion
//                                     orders.map(o => o.order as LimitOrderFields),
//                                     orders.map(o => o.signature),
//                                     NULL_ADDRESS,
//                                 )
//                                 .getABIEncodedTransactionData(),
//                         ])
//                         .getABIEncodedTransactionData(),
//                 ])
//                 .callAsync();
//             expect(r).to.be.length(1);
//             r = testContract.getABIDecodedReturnData<SamplerCallResult[]>('batchCall', r[0].data);
//             expect(r).to.be.length(1);
//             expect(
//                 testContract.getABIDecodedReturnData('getLimitOrderFillableTakerAssetAmounts', r[0].data),
//             ).to.deep.eq(expected);
//         });
//     });
//
//     blockchainTests.resets('TwoHopSampler', () => {
//         before(async () => {
//             await testContract
//                 .createTokenExchanges([MAKER_TOKEN, TAKER_TOKEN, INTERMEDIATE_TOKEN])
//                 .awaitTransactionSuccessAsync();
//         });
//
//         it('sampleTwoHopSell', async () => {
//             // tslint:disable-next-line no-unnecessary-type-assertion
//             const sellAmount = _.last(getSampleAmounts(TAKER_TOKEN))!;
//             const uniswapV2FirstHopPath = [TAKER_TOKEN, INTERMEDIATE_TOKEN];
//             const uniswapV2FirstHop = testContract
//                 .sampleSellsFromUniswapV2(UNISWAP_V2_ROUTER, uniswapV2FirstHopPath, [constants.ZERO_AMOUNT])
//                 .getABIEncodedTransactionData();
//
//             const uniswapV2SecondHopPath = [INTERMEDIATE_TOKEN, randomAddress(), MAKER_TOKEN];
//             const uniswapV2SecondHop = testContract
//                 .sampleSellsFromUniswapV2(UNISWAP_V2_ROUTER, uniswapV2SecondHopPath, [constants.ZERO_AMOUNT])
//                 .getABIEncodedTransactionData();
//
//             const firstHopQuotes = [getDeterministicUniswapV2SellQuote(uniswapV2FirstHopPath, sellAmount)];
//             const expectedIntermediateAssetAmount = BigNumber.max(...firstHopQuotes);
//             const secondHopQuotes = [
//                 getDeterministicUniswapV2SellQuote(uniswapV2SecondHopPath, expectedIntermediateAssetAmount),
//             ];
//             const expectedBuyAmount = BigNumber.max(...secondHopQuotes);
//
//             const [firstHop, secondHop, buyAmount] = await testContract
//                 .sampleTwoHopSell([uniswapV2FirstHop], [uniswapV2SecondHop], sellAmount)
//                 .callAsync();
//             expect(firstHop.sourceIndex, 'First hop source index').to.bignumber.equal(
//                 firstHopQuotes.findIndex(quote => quote.isEqualTo(expectedIntermediateAssetAmount)),
//             );
//             expect(secondHop.sourceIndex, 'Second hop source index').to.bignumber.equal(
//                 secondHopQuotes.findIndex(quote => quote.isEqualTo(expectedBuyAmount)),
//             );
//             expect(buyAmount, 'Two hop buy amount').to.bignumber.equal(expectedBuyAmount);
//         });
//         it('sampleTwoHopBuy', async () => {
//             // tslint:disable-next-line no-unnecessary-type-assertion
//             const buyAmount = _.last(getSampleAmounts(MAKER_TOKEN))!;
//             const uniswapV2FirstHopPath = [TAKER_TOKEN, INTERMEDIATE_TOKEN];
//             const uniswapV2FirstHop = testContract
//                 .sampleBuysFromUniswapV2(UNISWAP_V2_ROUTER, uniswapV2FirstHopPath, [constants.ZERO_AMOUNT])
//                 .getABIEncodedTransactionData();
//
//             const uniswapV2SecondHopPath = [INTERMEDIATE_TOKEN, randomAddress(), MAKER_TOKEN];
//             const uniswapV2SecondHop = testContract
//                 .sampleBuysFromUniswapV2(UNISWAP_V2_ROUTER, uniswapV2SecondHopPath, [constants.ZERO_AMOUNT])
//                 .getABIEncodedTransactionData();
//
//             const secondHopQuotes = [getDeterministicUniswapV2BuyQuote(uniswapV2SecondHopPath, buyAmount)];
//             const expectedIntermediateAssetAmount = BigNumber.min(...secondHopQuotes);
//
//             const firstHopQuotes = [
//                 getDeterministicUniswapV2BuyQuote(uniswapV2FirstHopPath, expectedIntermediateAssetAmount),
//             ];
//             const expectedSellAmount = BigNumber.min(...firstHopQuotes);
//
//             const [firstHop, secondHop, sellAmount] = await testContract
//                 .sampleTwoHopBuy([uniswapV2FirstHop], [uniswapV2SecondHop], buyAmount)
//                 .callAsync();
//             expect(firstHop.sourceIndex, 'First hop source index').to.bignumber.equal(
//                 firstHopQuotes.findIndex(quote => quote.isEqualTo(expectedSellAmount)),
//             );
//             expect(secondHop.sourceIndex, 'Second hop source index').to.bignumber.equal(
//                 secondHopQuotes.findIndex(quote => quote.isEqualTo(expectedIntermediateAssetAmount)),
//             );
//             expect(sellAmount, 'Two hop sell amount').to.bignumber.equal(expectedSellAmount);
//         });
//     });
// });