Simulate EIP-1271 orders at creation

crates/configs/src/orderbook/mod.rs

@@ -20,6 +20,7 @@ use {
     std::{
         net::{Ipv4Addr, SocketAddr, SocketAddrV4},
         path::Path,
+        time::Duration,
     },
 };
 
@@ -59,6 +60,31 @@ pub struct OrderSimulationConfig {
     /// URL.
     #[serde(default)]
     pub tenderly: Option<crate::simulator::TenderlyConfig>,
+
+    /// Mode for the EIP-1271 order simulation.
+    #[serde(default)]
+    pub eip1271_simulation_mode: Eip1271SimulationMode,
+
+    /// Per-call timeout for the EIP-1271 order simulation.
+    #[serde(
+        default = "default_eip1271_simulation_timeout",
+        with = "humantime_serde"
+    )]
+    pub eip1271_simulation_timeout: Duration,
+}
+
+/// Mode for the EIP-1271 order simulation at order creation.
+#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+pub enum Eip1271SimulationMode {
+    Shadow,
+    Enforce,
+    #[default]
+    Disabled,
+}
+
+fn default_eip1271_simulation_timeout() -> Duration {
+    Duration::from_secs(2)
 }
 
 /// Top-level orderbook service configuration.
@@ -228,6 +254,8 @@ pub mod test_util {
                 order_simulation: Some(OrderSimulationConfig {
                     gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
                     tenderly: None,
+                    eip1271_simulation_mode: Default::default(),
+                    eip1271_simulation_timeout: std::time::Duration::from_secs(2),
                 }),
                 hide_competition_before_deadline: false,
             }
@@ -438,4 +466,36 @@ mod tests {
         );
         assert_eq!(config.http_client.timeout, deserialized.http_client.timeout)
     }
+
+    #[test]
+    fn parses_simulation_mode_default() {
+        let toml = r#"
+gas-limit = "0x1000000"
+"#;
+        let cfg: OrderSimulationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(cfg.eip1271_simulation_mode, Eip1271SimulationMode::Disabled);
+        assert_eq!(cfg.eip1271_simulation_timeout, Duration::from_secs(2));
+    }
+
+    #[test]
+    fn parses_simulation_mode_enforce() {
+        let toml = r#"
+gas-limit = "0x1000000"
+eip1271-simulation-mode = "enforce"
+eip1271-simulation-timeout = "5s"
+"#;
+        let cfg: OrderSimulationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(cfg.eip1271_simulation_mode, Eip1271SimulationMode::Enforce);
+        assert_eq!(cfg.eip1271_simulation_timeout, Duration::from_secs(5));
+    }
+
+    #[test]
+    fn parses_simulation_mode_disabled() {
+        let toml = r#"
+gas-limit = "0x1000000"
+eip1271-simulation-mode = "disabled"
+"#;
+        let cfg: OrderSimulationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(cfg.eip1271_simulation_mode, Eip1271SimulationMode::Disabled);
+    }
 }

crates/orderbook/src/api/post_order.rs

@@ -188,6 +188,11 @@ impl IntoResponse for ValidationErrorWrapper {
                 ),
             )
                 .into_response(),
+            ValidationError::SimulationFailed(reason) => (
+                StatusCode::BAD_REQUEST,
+                error("Eip1271SimulationFailed", reason),
+            )
+                .into_response(),
             ValidationError::InsufficientBalance => (
                 StatusCode::BAD_REQUEST,
                 error(

crates/orderbook/src/eip1271_simulation.rs

@@ -0,0 +1,54 @@
+use {
+    crate::order_simulator::{self, OrderSimulator},
+    async_trait::async_trait,
+    model::order::Order,
+    shared::order_validation::{Eip1271Simulating, Eip1271SimulationError},
+    std::sync::Arc,
+};
+
+/// Adapter exposing `OrderSimulator` via the
+/// `shared::order_validation::Eip1271Simulating` trait.
+///
+/// This is a temporary shim. Once the `simulator` crate is refactored to own
+/// `OrderSimulator`, `OrderValidator` can depend on it directly and this
+/// adapter can be deleted.
+pub struct OrderSimulatorAdapter {
+    inner: Arc<OrderSimulator>,
+}
+
+impl OrderSimulatorAdapter {
+    pub fn new(inner: Arc<OrderSimulator>) -> Self {
+        Self { inner }
+    }
+}
+
+#[async_trait]
+impl Eip1271Simulating for OrderSimulatorAdapter {
+    async fn simulate(&self, order: &Order) -> Result<(), Eip1271SimulationError> {
+        let swap = self
+            .inner
+            .encode_order(order, Vec::new(), None)
+            .await
+            .map_err(map_simulator_err)?;
+        let result = self
+            .inner
+            .simulate_swap(swap, None)
+            .await
+            .map_err(map_simulator_err)?;
+        match result.error {
+            None => Ok(()),
+            Some(reason) => Err(Eip1271SimulationError::Reverted {
+                reason,
+                tenderly_url: result.tenderly_url,
+            }),
+        }
+    }
+}
+
+fn map_simulator_err(err: order_simulator::Error) -> Eip1271SimulationError {
+    match err {
+        order_simulator::Error::Other(e) | order_simulator::Error::MalformedInput(e) => {
+            Eip1271SimulationError::Infra(e)
+        }
+    }
+}

crates/orderbook/src/lib.rs

@@ -3,6 +3,7 @@ pub mod app_data;
 pub mod arguments;
 pub mod database;
 pub mod dto;
+mod eip1271_simulation;
 mod ipfs;
 mod ipfs_app_data;
 pub mod order_simulator;

crates/orderbook/src/run.rs

@@ -41,7 +41,12 @@ use {
     },
     shared::{
         order_quoting::{self, OrderQuoter},
-        order_validation::{OrderValidPeriodConfiguration, OrderValidator},
+        order_validation::{
+            Eip1271SimulationMode,
+            Eip1271Simulator,
+            OrderValidPeriodConfiguration,
+            OrderValidator,
+        },
     },
     simulator::swap_simulator::SwapSimulator,
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
@@ -375,6 +380,58 @@ pub async fn run(config: Configuration) {
     let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
         .await
         .ok();
+
+    let (order_simulator, eip1271_simulator) = match config.order_simulation {
+        Some(sim_config) => {
+            let tenderly: Option<Box<dyn simulator::tenderly::Api>> =
+                sim_config.tenderly.as_ref().map(|tenderly_config| {
+                    Box::new(simulator::tenderly::TenderlyApi::new(
+                        tenderly_config,
+                        &http_factory,
+                        chain.id().to_string(),
+                    )) as _
+                });
+            let order_simulator = Arc::new(OrderSimulator::new(
+                SwapSimulator::new(
+                    balance_overrider.clone(),
+                    *settlement_contract.address(),
+                    *native_token.address(),
+                    current_block_stream.clone(),
+                    web3,
+                    sim_config
+                        .gas_limit
+                        .try_into()
+                        .expect("gas_limit must fit in u64"),
+                )
+                .await
+                .expect("failed to create SwapSimulator"),
+                chain.id().to_string(),
+                tenderly,
+            ));
+            let mode = match sim_config.eip1271_simulation_mode {
+                configs::orderbook::Eip1271SimulationMode::Shadow => {
+                    Some(Eip1271SimulationMode::Shadow)
+                }
+                configs::orderbook::Eip1271SimulationMode::Enforce => {
+                    Some(Eip1271SimulationMode::Enforce)
+                }
+                configs::orderbook::Eip1271SimulationMode::Disabled => None,
+            };
+            let eip1271_simulator = mode.map(|mode| {
+                let simulator: Arc<dyn shared::order_validation::Eip1271Simulating> = Arc::new(
+                    crate::eip1271_simulation::OrderSimulatorAdapter::new(order_simulator.clone()),
+                );
+                Eip1271Simulator {
+                    simulator,
+                    mode,
+                    timeout: sim_config.eip1271_simulation_timeout,
+                }
+            });
+            (Some(order_simulator), eip1271_simulator)
+        }
+        None => (None, None),
+    };
+
     let order_validator = Arc::new(OrderValidator::new(
         native_token.clone(),
         Arc::new(order_validation::banned::Users::new(
@@ -389,6 +446,7 @@ pub async fn run(config: Configuration) {
         optimal_quoter.clone(),
         balance_fetcher,
         signature_validator,
+        eip1271_simulator,
         Arc::new(postgres_write.clone()),
         config.order_validation.max_limit_orders_per_user,
         code_fetcher,
@@ -411,36 +469,6 @@ pub async fn run(config: Configuration) {
         ipfs,
     ));
 
-    let order_simulator = if let Some(config) = config.order_simulation {
-        let tenderly: Option<Box<dyn simulator::tenderly::Api>> =
-            config.tenderly.as_ref().map(|tenderly_config| {
-                Box::new(simulator::tenderly::TenderlyApi::new(
-                    tenderly_config,
-                    &http_factory,
-                    chain.id().to_string(),
-                )) as _
-            });
-        Some(Arc::new(OrderSimulator::new(
-            SwapSimulator::new(
-                balance_overrider.clone(),
-                *settlement_contract.address(),
-                *native_token.address(),
-                current_block_stream.clone(),
-                web3,
-                config
-                    .gas_limit
-                    .try_into()
-                    .expect("gas_limit must fit in u64"),
-            )
-            .await
-            .expect("failed to create SwapSimulator"),
-            chain.id().to_string(),
-            tenderly,
-        )))
-    } else {
-        None
-    };
-
     let orderbook = Arc::new(Orderbook::new(
         domain_separator,
         *settlement_contract.address(),