Baseline solver accurate tx gas estimation

crates/app-data/src/app_data.rs

@@ -355,6 +355,13 @@ impl Root {
             backend: None,
         }
     }
+
+    pub fn wrappers(&self) -> &[WrapperCall] {
+        self.metadata
+            .as_ref()
+            .map(|metadata| metadata.wrappers.as_slice())
+            .unwrap_or_default()
+    }
 }
 
 /// Caches whether a given app data document contains wrappers, keyed by

crates/configs/src/orderbook/mod.rs

@@ -13,7 +13,7 @@ use {
         price_estimation::PriceEstimation,
         shared::SharedConfig,
     },
-    alloy::primitives::Address,
+    alloy::primitives::{Address, U256},
     anyhow::anyhow,
     chrono::{DateTime, Utc},
     serde::{Deserialize, Serialize},
@@ -112,6 +112,11 @@ pub struct Configuration {
     /// 1inch, quote verification, balance overrides, etc.).
     #[serde(default)]
     pub price_estimation: PriceEstimation,
+
+    /// Configures if the gas limit for orders simulation. If set to None, the
+    /// endpoint is disabled.
+    #[serde(default)]
+    pub order_simulation_gas_limit: Option<U256>,
 }
 
 impl Configuration {
@@ -142,8 +147,10 @@ pub mod test_util {
                 default_bind_address,
                 native_price::NativePriceConfig,
             },
+            price_estimation::PriceEstimation,
             test_util::TestDefault,
         },
+        alloy::primitives::U256,
         std::path::Path,
     };
 
@@ -193,7 +200,17 @@ pub mod test_util {
                 database: TestDefault::test_default(),
                 http_client: Default::default(),
                 order_quoting: TestDefault::test_default(),
-                price_estimation: TestDefault::test_default(),
+                price_estimation: PriceEstimation {
+                    balance_overrides: crate::price_estimation::BalanceOverridesConfig {
+                        autodetect: true,
+                        ..Default::default()
+                    },
+                    ..TestDefault::test_default()
+                },
+                // Enable order simulation for testing
+                order_simulation_gas_limit: Some(
+                    U256::try_from(16777215).expect("u64 can be converted to U256"),
+                ),
             }
         }
     }
@@ -218,6 +235,7 @@ mod tests {
         active-order-competition-threshold = 10
         unsupported-tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
         eip1271-skip-creation-validation = true
+        order-simulation-gas-limit = "123456789"
 
         [banned-users]
         addresses = ["0xdead000000000000000000000000000000000000"]
@@ -252,6 +270,10 @@ mod tests {
         assert_eq!(config.unsupported_tokens.len(), 1);
         assert_eq!(config.banned_users.addresses.len(), 1);
         assert!(config.eip1271_skip_creation_validation);
+        assert_eq!(
+            config.order_simulation_gas_limit,
+            Some(U256::from(123456789u64))
+        );
 
         assert!(matches!(
             config.order_validation.same_tokens_policy,
@@ -354,6 +376,7 @@ mod tests {
             database: TestDefault::test_default(),
             http_client: Default::default(),
             price_estimation: Default::default(),
+            order_simulation_gas_limit: Default::default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();

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

@@ -12,10 +12,7 @@ use {
         infra::{self, solver::ManageNativeToken},
     },
     allowance::Allowance,
-    alloy::{
-        primitives::{Address, Bytes, FixedBytes, U256},
-        sol_types::SolCall,
-    },
+    alloy::primitives::{Address, Bytes, FixedBytes, U256},
     contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
     eth_domain_types::{self as eth, Ether, allowance},
     itertools::Itertools,
@@ -209,9 +206,6 @@ pub fn tx(
         interactions.push(unwrap(native_unwrap, contracts.weth()));
     }
 
-    let has_flashloans = !solution.flashloans.is_empty();
-    let has_wrappers = !solution.wrappers.is_empty();
-
     // Encode the base settlement calldata
     let mut settle_calldata = contracts
         .settlement()
@@ -230,21 +224,24 @@ pub fn tx(
 
     // Append auction ID to settlement calldata
     settle_calldata.extend(auction.id().ok_or(Error::MissingAuctionId)?.to_be_bytes());
+    let has_flashloans = !solution.flashloans.is_empty();
+    let has_wrappers = !solution.wrappers.is_empty();
 
     let (to, calldata) = if has_flashloans && has_wrappers {
         return Err(Error::FlashloanWrappersIncompatible);
     } else if has_flashloans {
         encode_flashloan_settlement(solution, contracts, settle_calldata)?
     } else if has_wrappers {
-        encode_wrapper_settlement(solution, settle_calldata)
+        simulator::encoding::encode_wrapper_settlement(&solution.wrappers, settle_calldata.into())
+            .expect("wrappers is not empty")
     } else {
-        (*contracts.settlement().address(), settle_calldata)
+        (*contracts.settlement().address(), settle_calldata.into())
     };
 
     Ok(eth::Tx {
         from: solution.solver().address(),
         to,
-        input: calldata.into(),
+        input: calldata,
         value: Ether::zero(),
         access_list: Default::default(),
     })
@@ -260,7 +257,7 @@ fn encode_flashloan_settlement(
     solution: &super::Solution,
     contracts: &infra::blockchain::Contracts,
     settle_calldata: Vec<u8>,
-) -> Result<(eth::Address, Vec<u8>), Error> {
+) -> Result<(eth::Address, Bytes), Error> {
     // Get flashloan router contract
     let router = contracts
         .flashloan_router()
@@ -284,59 +281,7 @@ fn encode_flashloan_settlement(
         .calldata()
         .to_vec();
 
-    Ok((*router.address(), calldata))
-}
-
-/// Encodes a settlement transaction that uses wrapper contracts.
-///
-/// Takes the base settlement calldata and wraps it in a wrappedSettleCall
-/// with encoded wrapper metadata. Since wrappers are a chain, the wrapper
-/// address to call is also processed by this function.
-///
-/// Returns (first_wrapper_address, wrapped_calldata)
-fn encode_wrapper_settlement(
-    solution: &super::Solution,
-    settle_calldata: Vec<u8>,
-) -> (eth::Address, Vec<u8>) {
-    // Encode wrapper metadata
-    let wrapper_data = encode_wrapper_data(&solution.wrappers);
-
-    // Create wrappedSettleCall
-    let calldata = contracts::alloy::ICowWrapper::ICowWrapper::wrappedSettleCall {
-        settleData: settle_calldata.into(),
-        wrapperData: wrapper_data.into(),
-    }
-    .abi_encode();
-
-    (solution.wrappers[0].address, calldata)
-}
-
-/// Encodes wrapper metadata for wrapper settlement calls.
-///
-/// The format is:
-/// - For wrappers after the first: 20 bytes (address)
-/// - For each wrapper: 2 bytes (data length as u16 in native endian) + data
-///
-/// More information about wrapper encoding:
-/// https://www.notion.so/cownation/Generalized-Wrapper-2798da5f04ca8095a2d4c56b9d17134e?source=copy_link#2858da5f04ca807980bbf7f845354120
-///
-/// Note: The first wrapper address is omitted from the encoded data since it's
-/// already used as the transaction target.
-fn encode_wrapper_data(wrappers: &[super::WrapperCall]) -> Vec<u8> {
-    let mut wrapper_data = Vec::new();
-
-    for (index, w) in wrappers.iter().enumerate() {
-        // Skip first wrapper's address (it's the transaction target)
-        if index != 0 {
-            wrapper_data.extend(w.address.as_slice());
-        }
-
-        // Encode data length as u16 in native endian, then the data itself
-        wrapper_data.extend((w.data.len() as u16).to_be_bytes().to_vec());
-        wrapper_data.extend(w.data.clone());
-    }
-
-    wrapper_data
+    Ok((*router.address(), calldata.into()))
 }
 
 pub fn liquidity_interaction(

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

@@ -20,7 +20,7 @@ use {
     itertools::Itertools,
     num::{BigRational, One},
     number::conversions::{big_rational_to_u256, u256_to_big_int, u256_to_big_rational},
-    simulator::{self, Simulator},
+    simulator::{self, Simulator, encoding::WrapperCall},
     solvers_dto::solution::Flashloan,
     std::{
         collections::{BTreeSet, HashMap, HashSet, hash_map::Entry},
@@ -41,12 +41,6 @@ pub use {error::Error, interaction::Interaction, settlement::Settlement, trade::
 
 type Prices = HashMap<eth::TokenAddress, eth::U256>;
 
-#[derive(Clone)]
-pub struct WrapperCall {
-    pub address: eth::Address,
-    pub data: Vec<u8>,
-}
-
 // TODO Add a constructor and ensure that the clearing prices are included for
 // each trade
 /// A solution represents a set of orders which the solver has found an optimal

crates/driver/src/infra/solver/dto/solution.rs

@@ -2,7 +2,7 @@ use {
     crate::{
         domain::{
             self,
-            competition::{self, solution::WrapperCall},
+            competition::{self},
             liquidity,
         },
         infra::Solver,
@@ -15,6 +15,7 @@ use {
         DomainSeparator,
         order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
     },
+    simulator::encoding::WrapperCall,
     std::{collections::HashMap, str::FromStr},
 };
 
@@ -272,7 +273,7 @@ impl Solutions {
                             }).collect()),
                     solution.wrappers.iter().cloned().map(|w| WrapperCall {
                         address: w.address,
-                        data: w.data,
+                        data: w.data.into(),
                     }).collect(),
                 )
                 .map_err(|err| match err {

crates/e2e/src/setup/mod.rs

@@ -94,6 +94,7 @@ const DEFAULT_FILTERS: &[&str] = &[
     "solver=debug",
     "solvers=debug",
     "orderbook::api::request_summary=off",
+    "simulator=debug",
 ];
 
 fn with_default_filters<T>(custom_filters: impl IntoIterator<Item = T>) -> Vec<String>

crates/e2e/tests/e2e/main.rs

@@ -25,6 +25,7 @@ mod liquidity;
 mod liquidity_source_notification;
 mod malformed_requests;
 mod order_cancellation;
+mod order_simulation;
 mod parallel_settlement;
 mod partial_fill;
 mod partially_fillable_balance;

crates/e2e/tests/e2e/order_simulation.rs

@@ -0,0 +1,81 @@
+use {
+    configs::test_util::TestDefault,
+    e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
+    ethrpc::{Web3, alloy::CallBuilderExt},
+    model::{
+        order::{OrderCreation, OrderKind},
+        order_simulator::OrderSimulation,
+        signature::EcdsaSigningScheme,
+    },
+    number::units::EthUnit,
+    reqwest::StatusCode,
+};
+
+#[tokio::test]
+#[ignore]
+async fn local_node_order_simulation() {
+    run_test(order_simulation).await;
+}
+
+async fn order_simulation(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 2u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+
+    let client = services.client();
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let response = response.json::<OrderSimulation>().await.unwrap();
+    assert_eq!(response.error, None);
+}