Baseline solver accurate tx gas estimation

crates/driver/src/domain/quote.rs

@@ -16,7 +16,7 @@ use {
         util,
     },
     chrono::Utc,
-    eth_domain_types as eth,
+    eth_domain_types::{self as eth, Address},
     std::collections::{HashMap, HashSet},
 };
 
@@ -118,6 +118,9 @@ pub struct Order {
     pub amount: order::TargetAmount,
     pub side: order::Side,
     pub deadline: chrono::DateTime<chrono::Utc>,
+    pub owner: Address,
+    pub pre_interactions: Vec<domain::Interaction>,
+    pub post_interactions: Vec<domain::Interaction>,
 }
 
 impl Order {
@@ -177,7 +180,7 @@ impl Order {
         competition::Auction::new(
             None,
             vec![competition::Order {
-                uid: Default::default(),
+                uid: competition::order::Uid::from_parts(eth::B256::ZERO, self.owner, u32::MAX),
                 receiver: None,
                 created: u32::try_from(Utc::now().timestamp())
                     .unwrap_or(u32::MIN)
@@ -193,14 +196,14 @@ impl Order {
                 },
                 app_data: Default::default(),
                 partial: competition::order::Partial::No,
-                pre_interactions: Default::default(),
-                post_interactions: Default::default(),
+                pre_interactions: self.pre_interactions.clone(),
+                post_interactions: self.post_interactions.clone(),
                 sell_token_balance: competition::order::SellTokenBalance::Erc20,
                 buy_token_balance: competition::order::BuyTokenBalance::Erc20,
                 signature: competition::order::Signature {
                     scheme: competition::order::signature::Scheme::Eip1271,
                     data: Default::default(),
-                    signer: Default::default(),
+                    signer: self.owner,
                 },
                 protocol_fees: Default::default(),
                 quote: Default::default(),

crates/driver/src/infra/api/routes/quote/dto/mod.rs

@@ -2,6 +2,6 @@ mod order;
 mod quote;
 
 pub use {
-    order::{Error as OrderError, Order},
+    order::{Error as OrderError, Order, PostOrder},
     quote::Quote,
 };

crates/driver/src/infra/api/routes/quote/dto/order.rs

@@ -1,12 +1,25 @@
 use {
-    crate::domain::{competition, quote},
+    crate::domain::{self, competition, quote},
     eth_domain_types as eth,
     serde::Deserialize,
     serde_with::serde_as,
 };
 
 impl Order {
     pub fn into_domain(self) -> quote::Order {
+        self.into_domain_with_interactions(
+            Default::default(),
+            Default::default(),
+            Default::default(),
+        )
+    }
+
+    pub fn into_domain_with_interactions(
+        self,
+        owner: eth::Address,
+        pre_interactions: Vec<domain::Interaction>,
+        post_interactions: Vec<domain::Interaction>,
+    ) -> quote::Order {
         quote::Order {
             tokens: quote::Tokens::new(self.sell_token.into(), self.buy_token.into()),
             amount: self.amount.into(),
@@ -15,6 +28,9 @@ impl Order {
                 Kind::Buy => competition::order::Side::Buy,
             },
             deadline: self.deadline,
+            owner,
+            pre_interactions,
+            post_interactions,
         }
     }
 }
@@ -38,6 +54,61 @@ enum Kind {
     Buy,
 }
 
+/// Order body for the POST /quote endpoint, which additionally allows
+/// specifying pre/post interactions.
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PostOrder {
+    #[serde(flatten)]
+    pub order: Order,
+    #[serde(default)]
+    pub from: eth::Address,
+    #[serde(default)]
+    pub interactions: Interactions,
+}
+
+impl PostOrder {
+    pub fn into_domain(self) -> quote::Order {
+        self.order.into_domain_with_interactions(
+            self.from,
+            self.interactions.pre.into_iter().map(Into::into).collect(),
+            self.interactions.post.into_iter().map(Into::into).collect(),
+        )
+    }
+}
+
+#[serde_as]
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Interactions {
+    #[serde(default)]
+    pub pre: Vec<Interaction>,
+    #[serde(default)]
+    pub post: Vec<Interaction>,
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Interaction {
+    pub target: eth::Address,
+    #[serde_as(as = "serde_ext::U256")]
+    pub value: eth::U256,
+    #[serde_as(as = "serde_ext::Hex")]
+    pub call_data: Vec<u8>,
+}
+
+impl From<Interaction> for domain::Interaction {
+    fn from(i: Interaction) -> Self {
+        Self {
+            target: i.target,
+            value: i.value.into(),
+            call_data: i.call_data.into(),
+        }
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("received an order with identical buy and sell tokens")]

crates/driver/src/infra/api/routes/quote/mod.rs

@@ -11,15 +11,30 @@ mod dto;
 pub use dto::OrderError;
 
 pub(in crate::infra::api) fn quote(router: axum::Router<State>) -> axum::Router<State> {
-    router.route("/quote", axum::routing::get(route))
+    router
+        .route("/quote", axum::routing::get(get))
+        .route("/quote", axum::routing::post(post))
 }
 
-async fn route(
+async fn get(
     state: axum::extract::State<State>,
     LoggingQuery(order): LoggingQuery<dto::Order>,
+) -> Result<axum::Json<dto::Quote>, (axum::http::StatusCode, axum::Json<Error>)> {
+    execute(state, order.into_domain()).await
+}
+
+async fn post(
+    state: axum::extract::State<State>,
+    axum::Json(order): axum::Json<dto::PostOrder>,
+) -> Result<axum::Json<dto::Quote>, (axum::http::StatusCode, axum::Json<Error>)> {
+    execute(state, order.into_domain()).await
+}
+
+async fn execute(
+    state: axum::extract::State<State>,
+    order: crate::domain::quote::Order,
 ) -> Result<axum::Json<dto::Quote>, (axum::http::StatusCode, axum::Json<Error>)> {
     let handle_request = async {
-        let order = order.into_domain();
         observe::quoting(&order);
         let quote = order
             .quote(

crates/e2e/src/setup/colocation.rs

@@ -77,6 +77,41 @@ uni-v3-node-url = "http://localhost:8545"
     }
 }
 
+pub async fn start_baseline_solver_with_gas_simulation(
+    name: String,
+    account: TestAccount,
+    weth: Address,
+    base_tokens: Vec<Address>,
+    max_hops: usize,
+    merge_solutions: bool,
+    settlement: Address,
+) -> SolverEngine {
+    let encoded_base_tokens = encode_base_tokens(base_tokens.clone());
+    let config_file = config_tmp_file(format!(
+        r#"
+weth = "{weth:?}"
+base-tokens = [{encoded_base_tokens}]
+max-hops = {max_hops}
+max-partial-attempts = 5
+native-token-price-estimation-amount = "100000000000000000"
+uni-v3-node-url = "http://localhost:8545"
+gas-simulation-node-url = "http://localhost:8545"
+gas-simulation-settlement = "{settlement:?}"
+        "#,
+    ));
+    let endpoint = start_solver(config_file, "baseline".to_string()).await;
+    SolverEngine {
+        name,
+        endpoint,
+        account,
+        base_tokens,
+        merge_solutions,
+        haircut_bps: 0,
+        submission_keys: vec![],
+        forwarder_contract: None,
+    }
+}
+
 async fn start_solver(config_file: TempPath, solver_name: String) -> Url {
     let args = vec![
         "solvers".to_string(),