import { getContractAddressesForChainOrThrow } from '@0x/contract-addresses';
import {
    assertRoughlyEquals,
    constants,
    expect,
    getRandomFloat,
    getRandomInteger,
    Numberish,
    randomAddress,
} from '@0x/contracts-test-utils';

import { assetDataUtils, generatePseudoRandomSalt } from '@0x/order-utils';
import { SignedOrder } from '@0x/types';
import { BigNumber, hexUtils } from '@0x/utils';
import * as _ from 'lodash';

import { MarketOperationUtils } from '../src/utils/market_operation_utils/';
import { constants as marketOperationUtilConstants } from '../src/utils/market_operation_utils/constants';
import { DexOrderSampler } from '../src/utils/market_operation_utils/sampler';
import { DexSample, ERC20BridgeSource } from '../src/utils/market_operation_utils/types';

const { BUY_SOURCES, SELL_SOURCES } = marketOperationUtilConstants;

// tslint:disable: custom-no-magic-numbers
describe('MarketOperationUtils tests', () => {
    const CHAIN_ID = 1;
    const contractAddresses = getContractAddressesForChainOrThrow(CHAIN_ID);
    const ETH2DAI_BRIDGE_ADDRESS = contractAddresses.eth2DaiBridge;
    const KYBER_BRIDGE_ADDRESS = contractAddresses.kyberBridge;
    const UNISWAP_BRIDGE_ADDRESS = contractAddresses.uniswapBridge;

    const MAKER_TOKEN = randomAddress();
    const TAKER_TOKEN = randomAddress();
    const MAKER_ASSET_DATA = assetDataUtils.encodeERC20AssetData(MAKER_TOKEN);
    const TAKER_ASSET_DATA = assetDataUtils.encodeERC20AssetData(TAKER_TOKEN);
    let originalSamplerOperations: any;

    before(() => {
        originalSamplerOperations = DexOrderSampler.ops;
    });

    after(() => {
        DexOrderSampler.ops = originalSamplerOperations;
    });

    function createOrder(overrides?: Partial<SignedOrder>): SignedOrder {
        return {
            chainId: CHAIN_ID,
            exchangeAddress: contractAddresses.exchange,
            makerAddress: constants.NULL_ADDRESS,
            takerAddress: constants.NULL_ADDRESS,
            senderAddress: constants.NULL_ADDRESS,
            feeRecipientAddress: randomAddress(),
            salt: generatePseudoRandomSalt(),
            expirationTimeSeconds: getRandomInteger(0, 2 ** 64),
            makerAssetData: MAKER_ASSET_DATA,
            takerAssetData: TAKER_ASSET_DATA,
            makerFeeAssetData: constants.NULL_BYTES,
            takerFeeAssetData: constants.NULL_BYTES,
            makerAssetAmount: getRandomInteger(1, 1e18),
            takerAssetAmount: getRandomInteger(1, 1e18),
            makerFee: constants.ZERO_AMOUNT,
            takerFee: constants.ZERO_AMOUNT,
            signature: hexUtils.random(),
            ...overrides,
        };
    }

    function getSourceFromAssetData(assetData: string): ERC20BridgeSource {
        if (assetData.length === 74) {
            return ERC20BridgeSource.Native;
        }
        const bridgeAddress = hexUtils.slice(assetData, 48, 68).toLowerCase();
        switch (bridgeAddress) {
            case KYBER_BRIDGE_ADDRESS.toLowerCase():
                return ERC20BridgeSource.Kyber;
            case ETH2DAI_BRIDGE_ADDRESS.toLowerCase():
                return ERC20BridgeSource.Eth2Dai;
            case UNISWAP_BRIDGE_ADDRESS.toLowerCase():
                return ERC20BridgeSource.Uniswap;
            default:
                break;
        }
        throw new Error(`Unknown bridge address: ${bridgeAddress}`);
    }

    function assertSamePrefix(actual: string, expected: string): void {
        expect(actual.substr(0, expected.length)).to.eq(expected);
    }

    function createOrdersFromSellRates(takerAssetAmount: BigNumber, rates: Numberish[]): SignedOrder[] {
        const singleTakerAssetAmount = takerAssetAmount.div(rates.length).integerValue(BigNumber.ROUND_UP);
        return rates.map(r =>
            createOrder({
                makerAssetAmount: singleTakerAssetAmount.times(r).integerValue(),
                takerAssetAmount: singleTakerAssetAmount,
            }),
        );
    }

    function createOrdersFromBuyRates(makerAssetAmount: BigNumber, rates: Numberish[]): SignedOrder[] {
        const singleMakerAssetAmount = makerAssetAmount.div(rates.length).integerValue(BigNumber.ROUND_UP);
        return rates.map(r =>
            createOrder({
                makerAssetAmount: singleMakerAssetAmount,
                takerAssetAmount: singleMakerAssetAmount.div(r).integerValue(),
            }),
        );
    }

    const ORDER_DOMAIN = {
        exchangeAddress: contractAddresses.exchange,
        chainId: CHAIN_ID,
    };

    type GetQuotesOperation = (makerToken: string, takerToken: string, fillAmounts: BigNumber[]) => BigNumber[];

    function createGetQuotesOperationFromSellRates(rates: Numberish[]): GetQuotesOperation {
        return (makerToken: string, takerToken: string, fillAmounts: BigNumber[]) => {
            return fillAmounts.map((a, i) => a.times(rates[i]).integerValue());
        };
    }

    function createGetQuotesOperationFromBuyRates(rates: Numberish[]): GetQuotesOperation {
        return (makerToken: string, takerToken: string, fillAmounts: BigNumber[]) => {
            return fillAmounts.map((a, i) => a.div(rates[i]).integerValue());
        };
    }

    type GetMultipleQuotesOperation = (
        sources: ERC20BridgeSource[],
        makerToken: string,
        takerToken: string,
        fillAmounts: BigNumber[],
    ) => DexSample[][];

    function createGetMultipleQuotesOperationFromSellRates(rates: RatesBySource): GetMultipleQuotesOperation {
        return (sources: ERC20BridgeSource[], makerToken: string, takerToken: string, fillAmounts: BigNumber[]) => {
            return sources.map(s =>
                fillAmounts.map((a, i) => ({
                    source: s,
                    input: a,
                    output: a.times(rates[s][i]).integerValue(),
                })),
            );
        };
    }

    function createGetMultipleQuotesOperationFromBuyRates(rates: RatesBySource): GetMultipleQuotesOperation {
        return (sources: ERC20BridgeSource[], makerToken: string, takerToken: string, fillAmounts: BigNumber[]) => {
            return sources.map(s =>
                fillAmounts.map((a, i) => ({
                    source: s,
                    input: a,
                    output: a.div(rates[s][i]).integerValue(),
                })),
            );
        };
    }

    function createDecreasingRates(count: number): BigNumber[] {
        const rates: BigNumber[] = [];
        const initialRate = getRandomFloat(1e-3, 1e2);
        _.times(count, () => getRandomFloat(0.95, 1)).forEach((r, i) => {
            const prevRate = i === 0 ? initialRate : rates[i - 1];
            rates.push(prevRate.times(r));
        });
        return rates;
    }

    const NUM_SAMPLES = 3;

    interface RatesBySource {
        [source: string]: Numberish[];
    }

    const DEFAULT_RATES: RatesBySource = {
        [ERC20BridgeSource.Native]: createDecreasingRates(NUM_SAMPLES),
        [ERC20BridgeSource.Eth2Dai]: createDecreasingRates(NUM_SAMPLES),
        [ERC20BridgeSource.Kyber]: createDecreasingRates(NUM_SAMPLES),
        [ERC20BridgeSource.Uniswap]: createDecreasingRates(NUM_SAMPLES),
    };

    function findSourceWithMaxOutput(rates: RatesBySource): ERC20BridgeSource {
        const minSourceRates = Object.keys(rates).map(s => _.last(rates[s]) as BigNumber);
        const bestSourceRate = BigNumber.max(...minSourceRates);
        let source = Object.keys(rates)[_.findIndex(minSourceRates, t => bestSourceRate.eq(t))] as ERC20BridgeSource;
        // Native order rates play by different rules.
        if (source !== ERC20BridgeSource.Native) {
            const nativeTotalRate = BigNumber.sum(...rates[ERC20BridgeSource.Native]).div(
                rates[ERC20BridgeSource.Native].length,
            );
            if (nativeTotalRate.gt(bestSourceRate)) {
                source = ERC20BridgeSource.Native;
            }
        }
        return source;
    }

    const DEFAULT_OPS = {
        getOrderFillableTakerAmounts(orders: SignedOrder[]): BigNumber[] {
            return orders.map(o => o.takerAssetAmount);
        },
        getOrderFillableMakerAmounts(orders: SignedOrder[]): BigNumber[] {
            return orders.map(o => o.makerAssetAmount);
        },
        getKyberSellQuotes: createGetQuotesOperationFromSellRates(DEFAULT_RATES[ERC20BridgeSource.Kyber]),
        getUniswapSellQuotes: createGetQuotesOperationFromSellRates(DEFAULT_RATES[ERC20BridgeSource.Uniswap]),
        getEth2DaiSellQuotes: createGetQuotesOperationFromSellRates(DEFAULT_RATES[ERC20BridgeSource.Eth2Dai]),
        getUniswapBuyQuotes: createGetQuotesOperationFromBuyRates(DEFAULT_RATES[ERC20BridgeSource.Uniswap]),
        getEth2DaiBuyQuotes: createGetQuotesOperationFromBuyRates(DEFAULT_RATES[ERC20BridgeSource.Eth2Dai]),
        getSellQuotes: createGetMultipleQuotesOperationFromSellRates(DEFAULT_RATES),
        getBuyQuotes: createGetMultipleQuotesOperationFromBuyRates(DEFAULT_RATES),
    };

    function replaceSamplerOps(ops: Partial<typeof DEFAULT_OPS> = {}): void {
        DexOrderSampler.ops = {
            ...DEFAULT_OPS,
            ...ops,
        } as any;
    }

    const MOCK_SAMPLER = ({
        async executeAsync(...ops: any[]): Promise<any[]> {
            return ops;
        },
        async executeBatchAsync(ops: any[]): Promise<any[]> {
            return ops;
        },
    } as any) as DexOrderSampler;

    describe('MarketOperationUtils', () => {
        let marketOperationUtils: MarketOperationUtils;

        before(async () => {
            marketOperationUtils = new MarketOperationUtils(MOCK_SAMPLER, contractAddresses, ORDER_DOMAIN);
        });

        describe('getMarketSellOrdersAsync()', () => {
            const FILL_AMOUNT = getRandomInteger(1, 1e18);
            const ORDERS = createOrdersFromSellRates(
                FILL_AMOUNT,
                _.times(NUM_SAMPLES, i => DEFAULT_RATES[ERC20BridgeSource.Native][i]),
            );
            const DEFAULT_OPTS = { numSamples: NUM_SAMPLES, runLimit: 0, sampleDistributionBase: 1 };

            beforeEach(() => {
                replaceSamplerOps();
            });

            it('queries `numSamples` samples', async () => {
                const numSamples = _.random(1, 16);
                let actualNumSamples = 0;
                replaceSamplerOps({
                    getSellQuotes: (sources, makerToken, takerToken, amounts) => {
                        actualNumSamples = amounts.length;
                        return DEFAULT_OPS.getSellQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketSellOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    numSamples,
                });
                expect(actualNumSamples).eq(numSamples);
            });

            it('polls all DEXes if `excludedSources` is empty', async () => {
                let sourcesPolled: ERC20BridgeSource[] = [];
                replaceSamplerOps({
                    getSellQuotes: (sources, makerToken, takerToken, amounts) => {
                        sourcesPolled = sources.slice();
                        return DEFAULT_OPS.getSellQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketSellOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    excludedSources: [],
                });
                expect(sourcesPolled.sort()).to.deep.eq(SELL_SOURCES.slice().sort());
            });

            it('does not poll DEXes in `excludedSources`', async () => {
                const excludedSources = _.sampleSize(SELL_SOURCES, _.random(1, SELL_SOURCES.length));
                let sourcesPolled: ERC20BridgeSource[] = [];
                replaceSamplerOps({
                    getSellQuotes: (sources, makerToken, takerToken, amounts) => {
                        sourcesPolled = sources.slice();
                        return DEFAULT_OPS.getSellQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketSellOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    excludedSources,
                });
                expect(sourcesPolled.sort()).to.deep.eq(_.without(SELL_SOURCES, ...excludedSources).sort());
            });

            it('returns the most cost-effective single source if `runLimit == 0`', async () => {
                const bestSource = findSourceWithMaxOutput(DEFAULT_RATES);
                expect(bestSource).to.exist('');
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    runLimit: 0,
                });
                const uniqueAssetDatas = _.uniq(improvedOrders.map(o => o.makerAssetData));
                expect(uniqueAssetDatas).to.be.length(1);
                expect(getSourceFromAssetData(uniqueAssetDatas[0])).to.be.eq(bestSource);
            });

            it('generates bridge orders with correct asset data', async () => {
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    DEFAULT_OPTS,
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    expect(getSourceFromAssetData(order.makerAssetData)).to.exist('');
                    const makerAssetDataPrefix = hexUtils.slice(
                        assetDataUtils.encodeERC20BridgeAssetData(
                            MAKER_TOKEN,
                            constants.NULL_ADDRESS,
                            constants.NULL_BYTES,
                        ),
                        0,
                        36,
                    );
                    assertSamePrefix(order.makerAssetData, makerAssetDataPrefix);
                    expect(order.takerAssetData).to.eq(TAKER_ASSET_DATA);
                }
            });

            it('generates bridge orders with correct taker amount', async () => {
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    DEFAULT_OPTS,
                );
                const totalTakerAssetAmount = BigNumber.sum(...improvedOrders.map(o => o.takerAssetAmount));
                expect(totalTakerAssetAmount).to.bignumber.gte(FILL_AMOUNT);
            });

            it('generates bridge orders with max slippage of `bridgeSlippage`', async () => {
                const bridgeSlippage = _.random(0.1, true);
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, bridgeSlippage },
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    const source = getSourceFromAssetData(order.makerAssetData);
                    const expectedMakerAmount = FILL_AMOUNT.times(_.last(DEFAULT_RATES[source]) as BigNumber);
                    const slippage = 1 - order.makerAssetAmount.div(expectedMakerAmount.plus(1)).toNumber();
                    assertRoughlyEquals(slippage, bridgeSlippage, 8);
                }
            });

            it('ignores native orders below `dustFractionThreshold`', async () => {
                const dustFractionThreshold = 0.01;
                const dustAmount = FILL_AMOUNT.times(dustFractionThreshold).integerValue(BigNumber.ROUND_DOWN);
                const maxRate = BigNumber.max(...ORDERS.map(o => o.makerAssetAmount.div(o.takerAssetAmount)));
                // Pass in an order with the globally best rate but with a dust input amount.
                const dustOrder = createOrder({
                    makerAssetAmount: dustAmount.times(maxRate.plus(0.01)),
                    takerAssetAmount: dustAmount,
                });
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    _.shuffle([dustOrder, ...ORDERS]),
                    FILL_AMOUNT,
                    // Ignore all DEX sources so only native orders are returned.
                    { ...DEFAULT_OPTS, dustFractionThreshold, excludedSources: SELL_SOURCES },
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    expect(order.takerAssetAmount).to.bignumber.gt(dustAmount);
                }
            });

            it('can mix convex sources', async () => {
                const rates: RatesBySource = {};
                rates[ERC20BridgeSource.Native] = [0.4, 0.3, 0.2, 0.1];
                rates[ERC20BridgeSource.Uniswap] = [0.5, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Eth2Dai] = [0.6, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Kyber] = [0.7, 0.05, 0.05, 0.05];
                replaceSamplerOps({
                    getSellQuotes: createGetMultipleQuotesOperationFromSellRates(rates),
                });
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    createOrdersFromSellRates(FILL_AMOUNT, rates[ERC20BridgeSource.Native]),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, numSamples: 4, runLimit: 512, noConflicts: false },
                );
                expect(improvedOrders).to.be.length(4);
                const orderSources = improvedOrders.map(o => getSourceFromAssetData(o.makerAssetData));
                const expectedSources = [
                    ERC20BridgeSource.Kyber,
                    ERC20BridgeSource.Eth2Dai,
                    ERC20BridgeSource.Uniswap,
                    ERC20BridgeSource.Native,
                ];
                expect(orderSources).to.deep.eq(expectedSources);
            });

            it('excludes Kyber when `noConflicts` enabled and Uniswap or Eth2Dai are used first', async () => {
                const rates: RatesBySource = {};
                rates[ERC20BridgeSource.Native] = [0.3, 0.2, 0.1, 0.05];
                rates[ERC20BridgeSource.Uniswap] = [0.5, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Eth2Dai] = [0.6, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Kyber] = [0.4, 0.05, 0.05, 0.05];
                replaceSamplerOps({
                    getSellQuotes: createGetMultipleQuotesOperationFromSellRates(rates),
                });
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    createOrdersFromSellRates(FILL_AMOUNT, rates[ERC20BridgeSource.Native]),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, numSamples: 4, runLimit: 512, noConflicts: true },
                );
                expect(improvedOrders).to.be.length(4);
                const orderSources = improvedOrders.map(o => getSourceFromAssetData(o.makerAssetData));
                const expectedSources = [
                    ERC20BridgeSource.Eth2Dai,
                    ERC20BridgeSource.Uniswap,
                    ERC20BridgeSource.Native,
                    ERC20BridgeSource.Native,
                ];
                expect(orderSources).to.deep.eq(expectedSources);
            });

            it('excludes Uniswap and Eth2Dai when `noConflicts` enabled and Kyber is used first', async () => {
                const rates: RatesBySource = {};
                rates[ERC20BridgeSource.Native] = [0.1, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Uniswap] = [0.15, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Eth2Dai] = [0.15, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Kyber] = [0.7, 0.05, 0.05, 0.05];
                replaceSamplerOps({
                    getSellQuotes: createGetMultipleQuotesOperationFromSellRates(rates),
                });
                const improvedOrders = await marketOperationUtils.getMarketSellOrdersAsync(
                    createOrdersFromSellRates(FILL_AMOUNT, rates[ERC20BridgeSource.Native]),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, numSamples: 4, runLimit: 512, noConflicts: true },
                );
                expect(improvedOrders).to.be.length(4);
                const orderSources = improvedOrders.map(o => getSourceFromAssetData(o.makerAssetData));
                const expectedSources = [
                    ERC20BridgeSource.Kyber,
                    ERC20BridgeSource.Native,
                    ERC20BridgeSource.Native,
                    ERC20BridgeSource.Native,
                ];
                expect(orderSources).to.deep.eq(expectedSources);
            });
        });

        describe('getMarketBuyOrdersAsync()', () => {
            const FILL_AMOUNT = getRandomInteger(1, 1e18);
            const ORDERS = createOrdersFromBuyRates(
                FILL_AMOUNT,
                _.times(NUM_SAMPLES, () => DEFAULT_RATES[ERC20BridgeSource.Native][0]),
            );
            const DEFAULT_OPTS = { numSamples: NUM_SAMPLES, runLimit: 0, sampleDistributionBase: 1 };

            beforeEach(() => {
                replaceSamplerOps();
            });

            it('queries `numSamples` samples', async () => {
                const numSamples = _.random(1, 16);
                let actualNumSamples = 0;
                replaceSamplerOps({
                    getBuyQuotes: (sources, makerToken, takerToken, amounts) => {
                        actualNumSamples = amounts.length;
                        return DEFAULT_OPS.getBuyQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketBuyOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    numSamples,
                });
                expect(actualNumSamples).eq(numSamples);
            });

            it('polls all DEXes if `excludedSources` is empty', async () => {
                let sourcesPolled: ERC20BridgeSource[] = [];
                replaceSamplerOps({
                    getBuyQuotes: (sources, makerToken, takerToken, amounts) => {
                        sourcesPolled = sources.slice();
                        return DEFAULT_OPS.getBuyQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketBuyOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    excludedSources: [],
                });
                expect(sourcesPolled).to.deep.eq(BUY_SOURCES);
            });

            it('does not poll DEXes in `excludedSources`', async () => {
                const excludedSources = _.sampleSize(SELL_SOURCES, _.random(1, SELL_SOURCES.length));
                let sourcesPolled: ERC20BridgeSource[] = [];
                replaceSamplerOps({
                    getBuyQuotes: (sources, makerToken, takerToken, amounts) => {
                        sourcesPolled = sources.slice();
                        return DEFAULT_OPS.getBuyQuotes(sources, makerToken, takerToken, amounts);
                    },
                });
                await marketOperationUtils.getMarketBuyOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    excludedSources,
                });
                expect(sourcesPolled).to.deep.eq(_.without(BUY_SOURCES, ...excludedSources));
            });

            it('returns the most cost-effective single source if `runLimit == 0`', async () => {
                const bestSource = findSourceWithMaxOutput(DEFAULT_RATES);
                expect(bestSource).to.exist('');
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(ORDERS, FILL_AMOUNT, {
                    ...DEFAULT_OPTS,
                    runLimit: 0,
                });
                const uniqueAssetDatas = _.uniq(improvedOrders.map(o => o.makerAssetData));
                expect(uniqueAssetDatas).to.be.length(1);
                expect(getSourceFromAssetData(uniqueAssetDatas[0])).to.be.eq(bestSource);
            });

            it('generates bridge orders with correct asset data', async () => {
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    DEFAULT_OPTS,
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    expect(getSourceFromAssetData(order.makerAssetData)).to.exist('');
                    const makerAssetDataPrefix = hexUtils.slice(
                        assetDataUtils.encodeERC20BridgeAssetData(
                            MAKER_TOKEN,
                            constants.NULL_ADDRESS,
                            constants.NULL_BYTES,
                        ),
                        0,
                        36,
                    );
                    assertSamePrefix(order.makerAssetData, makerAssetDataPrefix);
                    expect(order.takerAssetData).to.eq(TAKER_ASSET_DATA);
                }
            });

            it('generates bridge orders with correct taker amount', async () => {
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    DEFAULT_OPTS,
                );
                const totalMakerAssetAmount = BigNumber.sum(...improvedOrders.map(o => o.makerAssetAmount));
                expect(totalMakerAssetAmount).to.bignumber.gte(FILL_AMOUNT);
            });

            it('generates bridge orders with max slippage of `bridgeSlippage`', async () => {
                const bridgeSlippage = _.random(0.1, true);
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(
                    // Pass in empty orders to prevent native orders from being used.
                    ORDERS.map(o => ({ ...o, makerAssetAmount: constants.ZERO_AMOUNT })),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, bridgeSlippage },
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    const source = getSourceFromAssetData(order.makerAssetData);
                    const expectedTakerAmount = FILL_AMOUNT.div(_.last(DEFAULT_RATES[source]) as BigNumber);
                    const slippage = order.takerAssetAmount.div(expectedTakerAmount.plus(1)).toNumber() - 1;
                    assertRoughlyEquals(slippage, bridgeSlippage, 8);
                }
            });

            it('Ignores native orders below `dustFractionThreshold`', async () => {
                const dustFractionThreshold = 0.01;
                const dustAmount = FILL_AMOUNT.times(dustFractionThreshold).integerValue(BigNumber.ROUND_DOWN);
                const maxRate = BigNumber.max(...ORDERS.map(o => o.makerAssetAmount.div(o.takerAssetAmount)));
                // Pass in an order with the globally best rate but with a dust input amount.
                const dustOrder = createOrder({
                    makerAssetAmount: dustAmount,
                    takerAssetAmount: dustAmount.div(maxRate.plus(0.01)).integerValue(BigNumber.ROUND_DOWN),
                });
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(
                    _.shuffle([dustOrder, ...ORDERS]),
                    FILL_AMOUNT,
                    // Ignore all DEX sources so only native orders are returned.
                    { ...DEFAULT_OPTS, dustFractionThreshold, excludedSources: BUY_SOURCES },
                );
                expect(improvedOrders).to.not.be.length(0);
                for (const order of improvedOrders) {
                    expect(order.makerAssetAmount).to.bignumber.gt(dustAmount);
                }
            });

            it('can mix convex sources', async () => {
                const rates: RatesBySource = {};
                rates[ERC20BridgeSource.Native] = [0.4, 0.3, 0.2, 0.1];
                rates[ERC20BridgeSource.Uniswap] = [0.5, 0.05, 0.05, 0.05];
                rates[ERC20BridgeSource.Eth2Dai] = [0.6, 0.05, 0.05, 0.05];
                replaceSamplerOps({
                    getBuyQuotes: createGetMultipleQuotesOperationFromBuyRates(rates),
                });
                const improvedOrders = await marketOperationUtils.getMarketBuyOrdersAsync(
                    createOrdersFromBuyRates(FILL_AMOUNT, rates[ERC20BridgeSource.Native]),
                    FILL_AMOUNT,
                    { ...DEFAULT_OPTS, numSamples: 4, runLimit: 512 },
                );
                expect(improvedOrders).to.be.length(4);
                const orderSources = improvedOrders.map(o => getSourceFromAssetData(o.makerAssetData));
                const expectedSources = [
                    ERC20BridgeSource.Eth2Dai,
                    ERC20BridgeSource.Uniswap,
                    ERC20BridgeSource.Native,
                    ERC20BridgeSource.Native,
                ];
                expect(orderSources).to.deep.eq(expectedSources);
            });
        });
    });
});
// tslint:disable-next-line: max-file-line-count