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,14 @@ pub struct OrderSimulationConfig {
     /// URL.
     #[serde(default)]
     pub tenderly: Option<crate::simulator::TenderlyConfig>,
+
+    /// Per-call timeout for the order creation simulation.
+    #[serde(default = "default_simulation_timeout", with = "humantime_serde")]
+    pub timeout: Duration,
+}
+
+fn default_simulation_timeout() -> Duration {
+    Duration::from_secs(2)
 }
 
 /// Top-level orderbook service configuration.
@@ -171,6 +180,16 @@ pub mod test_util {
         std::path::Path,
     };
 
+    impl TestDefault for OrderSimulationConfig {
+        fn test_default() -> Self {
+            Self {
+                gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
+                tenderly: None,
+                timeout: std::time::Duration::from_secs(2),
+            }
+        }
+    }
+
     impl Configuration {
         pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
             Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
@@ -225,10 +244,7 @@ pub mod test_util {
                     ..TestDefault::test_default()
                 },
                 // Enable order simulation for testing
-                order_simulation: Some(OrderSimulationConfig {
-                    gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
-                    tenderly: None,
-                }),
+                order_simulation: Some(TestDefault::test_default()),
                 hide_competition_before_deadline: false,
             }
         }
@@ -438,4 +454,22 @@ mod tests {
         );
         assert_eq!(config.http_client.timeout, deserialized.http_client.timeout)
     }
+
+    #[test]
+    fn parses_order_simulation_defaults() {
+        let toml = r#"gas-limit = "16777216""#;
+        let cfg: OrderSimulationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(cfg.timeout, Duration::from_secs(2));
+        assert!(cfg.tenderly.is_none());
+    }
+
+    #[test]
+    fn parses_order_simulation_full() {
+        let toml = r#"
+            gas-limit = "16777216"
+            timeout = "5s"
+        "#;
+        let cfg: OrderSimulationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(cfg.timeout, Duration::from_secs(5));
+    }
 }

crates/cow-amm/src/amm.rs

@@ -67,13 +67,13 @@ impl Amm {
         // To avoid issues caused by that we check the validity of the signature.
         let hash = hashed_eip712_message(domain_separator, &template.order.hash_struct());
         validator
-            .validate_signature_and_get_additional_gas(SignatureCheck {
-                signer: self.address,
-                hash: hash.0,
-                signature: template.signature.to_bytes(),
-                interactions: template.pre_interactions.clone(),
-                balance_override: None,
-            })
+            .validate_signature_and_get_additional_gas(SignatureCheck::new(
+                self.address,
+                hash.0,
+                template.signature.to_bytes(),
+                template.pre_interactions.clone(),
+                None,
+            ))
             .await
             .context("invalid signature")?;
 

crates/e2e/tests/e2e/eip1271_creation_simulation.rs

@@ -0,0 +1,100 @@
+//! Local-node smoke test for the EIP-1271 creation-time simulation wiring.
+//!
+//! A Safe-signed order with empty `app_data` is accepted, proving that
+//! `OrderSimulator` runs alongside the cheap signature check without
+//! disrupting the happy path. The simulation runs in shadow mode (logs
+//! disagreements, never rejects). An enforce-mode rejection test will be
+//! added together with the enforce-mode follow-up PR.
+
+use {
+    configs::{
+        orderbook::{Configuration, OrderSimulationConfig},
+        test_util::TestDefault,
+    },
+    e2e::setup::{MintableToken, OnchainComponents, Services, run_test, safe::Safe},
+    model::order::{OrderCreation, OrderCreationAppData, OrderKind},
+    number::units::EthUnit,
+    shared::web3::Web3,
+};
+
+#[tokio::test]
+#[ignore]
+async fn local_node_eip1271_creation_simulation_accepts_valid_order() {
+    run_test(accepts_valid_order).await;
+}
+
+async fn accepts_valid_order(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+    let [solver] = onchain.make_solvers(1u64.eth()).await;
+    let [trader] = onchain.make_accounts(1u64.eth()).await;
+
+    let safe = Safe::deploy(trader, web3.provider.clone()).await;
+
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(100_000u64.eth(), 100_000u64.eth())
+        .await;
+    fund_safe(&safe, &token, &onchain).await;
+
+    let services = start_services_with_simulation(&onchain, solver).await;
+
+    let order = sign_order(&safe, &onchain, &token);
+
+    let uid = services
+        .create_order(&order)
+        .await
+        .expect("expected order to be accepted");
+    let stored = services.get_order(&uid).await.unwrap();
+    assert_eq!(stored.metadata.uid, uid);
+}
+
+async fn fund_safe(safe: &Safe, token: &MintableToken, onchain: &OnchainComponents) {
+    token.mint(safe.address(), 10u64.eth()).await;
+    safe.exec_alloy_call(
+        token
+            .approve(onchain.contracts().allowance, 10u64.eth())
+            .into_transaction_request(),
+    )
+    .await;
+}
+
+async fn start_services_with_simulation<'a>(
+    onchain: &'a OnchainComponents,
+    solver: e2e::setup::onchain_components::TestAccount,
+) -> Services<'a> {
+    let orderbook_config = Configuration {
+        order_simulation: Some(OrderSimulationConfig::test_default()),
+        ..Configuration::test_default()
+    };
+
+    let services = Services::new(onchain).await;
+    services
+        .start_protocol_with_args(
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
+            orderbook_config,
+            solver,
+        )
+        .await;
+    services
+}
+
+fn sign_order(
+    safe: &Safe,
+    onchain: &OnchainComponents,
+    sell_token: &MintableToken,
+) -> OrderCreation {
+    let mut order = OrderCreation {
+        kind: OrderKind::Sell,
+        sell_token: *sell_token.address(),
+        sell_amount: 5u64.eth(),
+        buy_token: *onchain.contracts().weth.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        from: Some(safe.address()),
+        app_data: OrderCreationAppData::Full {
+            full: "{}".to_string(),
+        },
+        ..Default::default()
+    };
+    safe.sign_order(&mut order, onchain);
+    order
+}

crates/e2e/tests/e2e/main.rs

@@ -16,6 +16,7 @@ mod cow_amm;
 mod database;
 mod debug_order;
 mod deprecated_endpoints;
+mod eip1271_creation_simulation;
 mod eip4626;
 mod eth_integration;
 mod eth_safe;

crates/e2e/tests/e2e/malformed_requests.rs

@@ -460,7 +460,7 @@ async fn http_validation(web3: Web3) {
         "zero sellAmount should return 422"
     );
 
-    // some fields missing → 422
+    // Invalid kind enum value → 422
     let response = client
         .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
@@ -510,15 +510,10 @@ async fn http_validation(web3: Web3) {
     );
     let body: Error = response.json().await.unwrap();
     assert!(
-        body.description.contains("app_data"),
+        body.description.contains("app data"),
         "error description should name the failing field. Got: {}",
         body.description
     );
-    assert!(
-        body.description.contains(bad_app_data),
-        "error description should include the bad value. Got: {}",
-        body.description
-    );
 }
 
 #[tokio::test]

crates/orderbook/src/run.rs

@@ -41,7 +41,7 @@ use {
     },
     shared::{
         order_quoting::{self, OrderQuoter},
-        order_validation::{OrderValidPeriodConfiguration, OrderValidator},
+        order_validation::{OrderSimulator, OrderValidPeriodConfiguration, OrderValidator},
     },
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
     token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
@@ -385,6 +385,49 @@ pub async fn run(config: Configuration) {
     let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
         .await
         .ok();
+
+    let order_simulator = match &config.order_simulation {
+        Some(sim_config) => {
+            let tenderly: Option<Arc<dyn simulator::tenderly::Api>> =
+                sim_config.tenderly.as_ref().map(|tenderly_config| {
+                    Arc::new(simulator::tenderly::TenderlyApi::new(
+                        tenderly_config,
+                        &http_factory,
+                        chain.id().to_string(),
+                    )) as _
+                });
+            Some(
+                simulator::simulation_builder::SettlementSimulator::new(
+                    settlement_contract.clone(),
+                    flashloan_router_address,
+                    hooks_trampoline_address,
+                    *native_token.address(),
+                    sim_config.gas_limit.saturating_to(),
+                    balance_overrider.clone(),
+                    current_block_stream.clone(),
+                    tenderly,
+                )
+                .await
+                .expect("failed to create SettlementSimulator"),
+            )
+        }
+        None => None,
+    };
+
+    let validator_simulator = config
+        .order_simulation
+        .as_ref()
+        .zip(order_simulator.clone())
+        .map(|(sim_config, settlement_simulator)| {
+            let simulator: Arc<dyn simulator::order_simulation::OrderSimulating> = Arc::new(
+                simulator::order_simulation::OrderSimulatorAdapter::new(settlement_simulator),
+            );
+            OrderSimulator {
+                simulator,
+                timeout: sim_config.timeout,
+            }
+        });
+
     let order_validator = Arc::new(OrderValidator::new(
         native_token.clone(),
         Arc::new(order_validation::banned::Users::new(
@@ -399,6 +442,7 @@ pub async fn run(config: Configuration) {
         optimal_quoter.clone(),
         balance_fetcher,
         signature_validator,
+        validator_simulator,
         Arc::new(postgres_write.clone()),
         config.order_validation.max_limit_orders_per_user,
         code_fetcher,
@@ -421,33 +465,6 @@ pub async fn run(config: Configuration) {
         ipfs,
     ));
 
-    let order_simulator = if let Some(config) = config.order_simulation {
-        let tenderly: Option<Arc<dyn simulator::tenderly::Api>> =
-            config.tenderly.as_ref().map(|tenderly_config| {
-                Arc::new(simulator::tenderly::TenderlyApi::new(
-                    tenderly_config,
-                    &http_factory,
-                    chain.id().to_string(),
-                )) as _
-            });
-        Some(
-            simulator::simulation_builder::SettlementSimulator::new(
-                settlement_contract.clone(),
-                flashloan_router_address,
-                hooks_trampoline_address,
-                *native_token.address(),
-                config.gas_limit.saturating_to(),
-                balance_overrider.clone(),
-                current_block_stream.clone(),
-                tenderly,
-            )
-            .await
-            .expect("failed to initialize SettlementSimulator"),
-        )
-    } else {
-        None
-    };
-
     let orderbook = Arc::new(Orderbook::new(
         domain_separator,
         *settlement_contract.address(),

crates/shared/Cargo.toml

@@ -56,6 +56,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 signature-validator = { workspace = true }
+simulator = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 token-info = { workspace = true }
@@ -75,6 +76,7 @@ mockall = { workspace = true }
 price-estimation = { workspace = true, features = ["test-util"] }
 regex = { workspace = true }
 signature-validator = { workspace = true, features = ["test-util"] }
+simulator = { workspace = true, features = ["test-util"] }
 testlib = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 toml = { workspace = true }