Driver sends quote response with JIT orders

crates/autopilot/src/run.rs

@@ -332,6 +332,7 @@ pub async fn run(args: Arguments) {
             code_fetcher: code_fetcher.clone(),
         },
     )
+    .await
     .expect("failed to initialize price estimator factory");
 
     let native_price_estimator = price_estimator_factory

crates/contracts/solidity/Solver.sol

@@ -31,8 +31,8 @@ contract Solver {
     /// @param trader - address of the order owner doing the trade
     /// @param sellToken - address of the token being sold
     /// @param sellAmount - amount being sold
-    /// @param buyToken - address of the token being bought
     /// @param nativeToken - ERC20 version of the chain's token
+    /// @param tokens - list of tokens used in the trade
     /// @param receiver - address receiving the bought tokens
     /// @param settlementCall - the calldata of the `settle()` call
     /// @param mockPreconditions - controls whether things like ETH wrapping
@@ -47,8 +47,8 @@ contract Solver {
         address payable trader,
         address sellToken,
         uint256 sellAmount,
-        address buyToken,
         address nativeToken,
+        address[] calldata tokens,
         address payable receiver,
         bytes calldata settlementCall,
         bool mockPreconditions
@@ -76,13 +76,14 @@ contract Solver {
         // contract.
         receiver.call{value: 0}("");
 
-        this.storeBalance(sellToken, address(settlementContract), false);
-        this.storeBalance(buyToken, address(settlementContract), false);
-        uint256 gasStart = gasleft();
-        address(settlementContract).doCall(settlementCall);
-        gasUsed = gasStart - gasleft() - _simulationOverhead;
-        this.storeBalance(sellToken, address(settlementContract), false);
-        this.storeBalance(buyToken, address(settlementContract), false);
+        // Store pre-settlement balances
+        _storeSettlementBalances(tokens, settlementContract);
+
+        gasUsed = _executeSettlement(address(settlementContract), settlementCall);
+
+        // Store post-settlement balances
+        _storeSettlementBalances(tokens, settlementContract);
+
         queriedBalances = _queriedBalances;
     }
 
@@ -104,4 +105,26 @@ contract Solver {
             _simulationOverhead += gasStart - gasleft() + 4460;
         }
     }
+
+    /// @dev Helper function that reads and stores the balances of the `settlementContract` for each token in `tokens`.
+    /// @param tokens - list of tokens used in the trade
+    /// @param settlementContract - the settlement contract whose balances are being read
+    function _storeSettlementBalances(address[] calldata tokens, ISettlement settlementContract) internal {
+        for (uint256 i = 0; i < tokens.length; i++) {
+            this.storeBalance(tokens[i], address(settlementContract), false);
+        }
+    }
+
+    /// @dev Executes the settlement and measures the gas used.
+    /// @param settlementContract The address of the settlement contract.
+    /// @param settlementCall The calldata for the settlement function.
+    /// @return gasUsed The amount of gas used during the settlement execution.
+    function _executeSettlement(
+        address settlementContract,
+        bytes calldata settlementCall
+    ) private returns (uint256 gasUsed) {
+        uint256 gasStart = gasleft();
+        address(settlementContract).doCall(settlementCall);
+        gasUsed = gasStart - gasleft() - _simulationOverhead;
+    }
 }

crates/driver/src/domain/competition/order/mod.rs

@@ -387,6 +387,7 @@ pub struct Jit {
     pub buy: eth::Asset,
     pub receiver: eth::Address,
     pub valid_to: util::Timestamp,
+    pub partially_fillable: bool,
     pub app_data: AppData,
     pub side: Side,
     pub sell_token_balance: SellTokenBalance,

crates/driver/src/domain/competition/order/signature.rs

@@ -42,6 +42,17 @@ pub enum Scheme {
     PreSign,
 }
 
+impl Scheme {
+    pub fn to_boundary_scheme(&self) -> model::signature::SigningScheme {
+        match self {
+            Scheme::Eip712 => model::signature::SigningScheme::Eip712,
+            Scheme::EthSign => model::signature::SigningScheme::EthSign,
+            Scheme::Eip1271 => model::signature::SigningScheme::Eip1271,
+            Scheme::PreSign => model::signature::SigningScheme::PreSign,
+        }
+    }
+}
+
 pub fn domain_separator(
     chain_id: chain::Id,
     verifying_contract: eth::ContractAddress,

crates/driver/src/domain/competition/solution/encoding.rs

@@ -47,13 +47,13 @@ pub fn tx(
     let mut native_unwrap = eth::TokenAmount(eth::U256::zero());
 
     // Encode uniform clearing price vector
-    for asset in solution
+    for (token, amount) in solution
         .clearing_prices()
-        .iter()
-        .sorted_by_cached_key(|asset| asset.token)
+        .into_iter()
+        .sorted_by_cached_key(|(token, _amount)| *token)
     {
-        tokens.push(asset.token.into());
-        clearing_prices.push(asset.amount.into());
+        tokens.push(token.into());
+        clearing_prices.push(amount);
     }
 
     // Encode trades with custom clearing prices
@@ -312,7 +312,7 @@ struct Flags {
     buy_token_balance: order::BuyTokenBalance,
 }
 
-mod codec {
+pub mod codec {
     use crate::domain::{competition::order, eth};
 
     // cf. https://github.com/cowprotocol/contracts/blob/v1.5.0/src/contracts/libraries/GPv2Trade.sol#L16
@@ -392,7 +392,7 @@ mod codec {
         )
     }
 
-    pub(super) fn signature(signature: &order::Signature) -> super::Bytes<Vec<u8>> {
+    pub fn signature(signature: &order::Signature) -> super::Bytes<Vec<u8>> {
         match signature.scheme {
             order::signature::Scheme::Eip712 | order::signature::Scheme::EthSign => {
                 signature.data.clone()

crates/driver/src/domain/competition/solution/mod.rs

@@ -174,6 +174,10 @@ impl Solution {
         &self.interactions
     }
 
+    pub fn pre_interactions(&self) -> &[eth::Interaction] {
+        &self.pre_interactions
+    }
+
     /// The solver which generated this solution.
     pub fn solver(&self) -> &Solver {
         &self.solver
@@ -401,11 +405,8 @@ impl Solution {
     ///
     /// The rule which relates two prices for tokens X and Y is:
     /// amount_x * price_x = amount_y * price_y
-    pub fn clearing_prices(&self) -> Vec<eth::Asset> {
-        let prices = self.prices.iter().map(|(&token, &amount)| eth::Asset {
-            token,
-            amount: amount.into(),
-        });
+    pub fn clearing_prices(&self) -> Prices {
+        let prices = self.prices.clone();
 
         if self.user_trades().any(|trade| trade.order().buys_eth()) {
             // The solution contains an order which buys ETH. Solvers only produce solutions
@@ -418,28 +419,26 @@ impl Solution {
             // If no order trades WETH, the WETH price is not necessary, only the ETH
             // price is needed. Remove the unneeded WETH price, which slightly reduces
             // gas used by the settlement.
-            let mut prices = if self.user_trades().all(|trade| {
+            let mut prices: Prices = if self.user_trades().all(|trade| {
                 trade.order().sell.token != self.weth.0 && trade.order().buy.token != self.weth.0
             }) {
                 prices
-                    .filter(|price| price.token != self.weth.0)
-                    .collect_vec()
+                    .into_iter()
+                    .filter(|(token, _price)| *token != self.weth.0)
+                    .collect()
             } else {
-                prices.collect_vec()
+                prices
             };
 
             // Add a clearing price for ETH equal to WETH.
-            prices.push(eth::Asset {
-                token: eth::ETH_TOKEN,
-                amount: self.prices[&self.weth.into()].to_owned().into(),
-            });
+            prices.insert(eth::ETH_TOKEN, self.prices[&self.weth.into()].to_owned());
 
             return prices;
         }
 
         // TODO: We should probably filter out all unused prices to save gas.
 
-        prices.collect_vec()
+        prices
     }
 
     /// Clearing price for the given token.

crates/driver/src/domain/competition/solution/settlement.rs

@@ -308,8 +308,8 @@ impl Settlement {
     pub fn prices(&self) -> HashMap<eth::TokenAddress, eth::TokenAmount> {
         self.solution
             .clearing_prices()
-            .iter()
-            .map(|asset| (asset.token, asset.amount))
+            .into_iter()
+            .map(|(token, amount)| (token, amount.into()))
             .collect()
     }
 }

crates/driver/src/domain/quote.rs

@@ -13,52 +13,37 @@ use {
             blockchain::{self, Ethereum},
             solver::{self, Solver},
         },
-        util::{self, conv::u256::U256Ext},
+        util,
     },
-    anyhow::Context,
     chrono::Utc,
-    num::CheckedDiv,
-    std::{collections::HashSet, iter, ops::Mul},
+    std::{
+        collections::{HashMap, HashSet},
+        iter,
+    },
 };
 
 /// A quote describing the expected outcome of an order.
 #[derive(Debug)]
 pub struct Quote {
-    /// The amount that can be bought if this was a sell order, or sold if this
-    /// was a buy order.
-    pub amount: eth::U256,
+    pub clearing_prices: HashMap<eth::H160, eth::U256>,
+    pub pre_interactions: Vec<eth::Interaction>,
     pub interactions: Vec<eth::Interaction>,
     pub solver: eth::Address,
     pub gas: Option<eth::Gas>,
     /// Which `tx.origin` is required to make the quote simulation pass.
     pub tx_origin: Option<eth::Address>,
+    pub jit_orders: Vec<solution::trade::Jit>,
 }
 
 impl Quote {
-    fn new(eth: &Ethereum, order: &Order, solution: competition::Solution) -> Result<Self, Error> {
-        let sell_price = solution
-            .clearing_price(order.tokens.sell)
-            .ok_or(QuotingFailed::ClearingSellMissing)?
-            .to_big_rational();
-        let buy_price = solution
-            .clearing_price(order.tokens.buy)
-            .ok_or(QuotingFailed::ClearingBuyMissing)?
-            .to_big_rational();
-        let order_amount = order.amount.0.to_big_rational();
-
-        let amount = match order.side {
-            order::Side::Sell => order_amount
-                .mul(sell_price)
-                .checked_div(&buy_price)
-                .context("div by zero: buy price")?,
-            order::Side::Buy => order_amount
-                .mul(&buy_price)
-                .checked_div(&sell_price)
-                .context("div by zero: sell price")?,
-        };
-
+    fn new(eth: &Ethereum, solution: competition::Solution) -> Result<Self, Error> {
         Ok(Self {
-            amount: eth::U256::from_big_rational(&amount)?,
+            clearing_prices: solution
+                .clearing_prices()
+                .into_iter()
+                .map(|(token, amount)| (token.into(), amount))
+                .collect(),
+            pre_interactions: solution.pre_interactions().to_vec(),
             interactions: solution
                 .interactions()
                 .iter()
@@ -70,6 +55,14 @@ impl Quote {
             solver: solution.solver().address(),
             gas: solution.gas(),
             tx_origin: *solution.solver().quote_tx_origin(),
+            jit_orders: solution
+                .trades()
+                .iter()
+                .filter_map(|trade| match trade {
+                    solution::Trade::Jit(jit) => Some(jit.clone()),
+                    _ => None,
+                })
+                .collect(),
         })
     }
 }
@@ -110,7 +103,6 @@ impl Order {
         let solutions = solver.solve(&auction, &liquidity).await?;
         Quote::new(
             eth,
-            self,
             // TODO(#1468): choose the best solution in the future, but for now just pick the
             // first solution
             solutions