Method new

crates/driver/src/tests/setup/solver.rs:61–543

Set up an HTTP server exposing a solver API and acting as a solver mock.

(config: Config<'_>)

impl Solver {
    /// Set up an HTTP server exposing a solver API and acting as a solver mock.
    pub async fn new(config: Config<'_>) -> Self {
        let mut solutions_json = Vec::new();
        let mut orders_json = Vec::new();
        for quote in config.quoted_orders.iter().filter(|q| !q.order.filtered) {
            // ETH orders get unwrapped into WETH by the driver before being passed to the
            // solver.
            let sell_token = if quote.order.sell_token == "ETH" {
                "WETH"
            } else {
                quote.order.sell_token
            };
            let buy_token = if quote.order.buy_token == "ETH" {
                "WETH"
            } else {
                quote.order.buy_token
            };
            let sell_amount = match quote.order.side {
                order::Side::Buy if config.quote => {
                    "22300745198530623141535718272648361505980416".to_owned()
                }
                order::Side::Buy => {
                    let mut current_sell_amount = quote.sell_amount();
                    for fee_policy in &quote.order.fee_policy {
                        match fee_policy {
                            // If the fees are handled in the driver, for volume based fee, we
                            // artificially reduce the limit sell amount
                            // for buy orders before sending to solvers. This
                            // allows driver to withhold volume based fee and not violate original
                            // limit prices.
                            fee::Policy::Volume { factor }
                                if config.fee_handler == FeeHandler::Driver =>
                            {
                                current_sell_amount = eth::TokenAmount(current_sell_amount)
                                    .apply_factor(1.0 / (1.0 + factor))
                                    .unwrap()
                                    .0;
                            }
                            _ => {}
                        }
                    }
                    // Make-room for the haircut: the driver subtracts a haircut
                    // post-hoc from buy_amount() (sell orders) / adds it to
                    // sell_amount() (buy orders). Tightening the auction limits
                    // here ensures solvers bid with enough headroom.
                    if config.haircut_bps > 0 {
                        let factor = f64::from(config.haircut_bps) / 10_000.0;
                        current_sell_amount = eth::TokenAmount(current_sell_amount)
                            .apply_factor(1.0 / (1.0 + factor))
                            .unwrap()
                            .0;
                    }
                    current_sell_amount.to_string()
                }
                _ => quote.sell_amount().to_string(),
            };
            let buy_amount = match quote.order.side {
                order::Side::Sell if config.quote => "1".to_owned(),
                order::Side::Sell => {