Simulate EIP-1271 orders at creation

crates/autopilot/src/infra/blockchain/contracts.rs

@@ -3,6 +3,7 @@ use {
     chain::Chain,
     contracts::{
         ChainalysisOracle,
+        FlashLoanRouter,
         GPv2AllowListAuthentication,
         GPv2Settlement,
         HooksTrampoline,
@@ -21,6 +22,7 @@ pub struct Contracts {
     balances: Balances::Instance,
     chainalysis_oracle: Option<ChainalysisOracle::Instance>,
     trampoline: HooksTrampoline::Instance,
+    flashloan_router: Address,
 
     /// The authenticator contract that decides which solver is allowed to
     /// submit settlements.
@@ -36,6 +38,7 @@ pub struct Addresses {
     pub weth: Option<Address>,
     pub balances: Option<Address>,
     pub trampoline: Option<Address>,
+    pub flashloan_router: Option<Address>,
 }
 
 impl Contracts {
@@ -80,6 +83,11 @@ impl Contracts {
             web3.provider.clone(),
         );
 
+        let flashloan_router = addresses
+            .flashloan_router
+            .or_else(|| FlashLoanRouter::deployment_address(&chain.id()))
+            .unwrap();
+
         let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
             .await
             .ok();
@@ -111,6 +119,7 @@ impl Contracts {
             settlement_domain_separator,
             authenticator,
             trampoline,
+            flashloan_router,
         }
     }
 
@@ -151,4 +160,8 @@ impl Contracts {
     pub fn authenticator(&self) -> &GPv2AllowListAuthentication::Instance {
         &self.authenticator
     }
+
+    pub fn flashloan_router(&self) -> Address {
+        self.flashloan_router
+    }
 }

crates/autopilot/src/run.rs

@@ -221,6 +221,7 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
         weth: config.shared.contracts.native_token,
         balances: config.shared.contracts.balances,
         trampoline: config.shared.contracts.hooks,
+        flashloan_router: config.shared.contracts.flashloan_router,
     };
     let current_block_args = shared::current_block::Arguments::from(&config.shared.current_block);
     let eth = ethereum(
@@ -314,6 +315,8 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
                 .await
                 .expect("failed to query solver authenticator address"),
             block_stream: eth.current_block().clone(),
+            flash_loan_router: eth.contracts().flashloan_router(),
+            hooks_trampoline: *eth.contracts().trampoline().address(),
         },
         factory::Components {
             http_factory: http_client::HttpClientFactory::new(&configs::http_client::HttpClient {

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/configs/src/shared.rs

@@ -182,6 +182,9 @@ pub struct ContractAddresses {
 
     /// The Balancer V2 Vault contract used for liquidity sourcing.
     pub balancer_v2_vault: Option<Address>,
+
+    /// The flashloan router contract.
+    pub flashloan_router: Option<Address>,
 }
 
 /// Logging configuration (log filter, output format).

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/src/setup/services.rs

@@ -143,6 +143,11 @@ impl<'a> Services<'a> {
                 native_token: Some(*self.contracts.weth.address()),
                 hooks: Some(*self.contracts.hooks.address()),
                 balancer_v2_vault: Some(*self.contracts.balancer_vault.address()),
+                flashloan_router: self
+                    .contracts
+                    .flashloan_router
+                    .as_ref()
+                    .map(|c| *c.address()),
             },
             ..Default::default()
         }

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

@@ -492,6 +492,13 @@ async fn http_validation(web3: Web3) {
             "kind": "sell",
             "owner": VALID_ADDRESS,
             "appData": bad_app_data,
+            "sellTokenBalance": "erc20",
+            "buyTokenBalance": "erc20",
+            "signingScheme": "eip1271",
+            "signature": "0x000000",
+            "feeAmount": "0",
+            "validTo": 12341234,
+            "partiallyFillable": false,
         }))
         .send()
         .await
@@ -503,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]
@@ -563,6 +565,14 @@ async fn simulation_not_enabled(web3: Web3) {
             "buyAmount": "1000000000000000000",
             "kind": "sell",
             "owner": VALID_ADDRESS,
+            "appData": "{}",
+            "sellTokenBalance": "erc20",
+            "buyTokenBalance": "erc20",
+            "signingScheme": "eip1271",
+            "signature": "0x000000",
+            "feeAmount": "0",
+            "validTo": 12341234,
+            "partiallyFillable": false,
         }))
         .send()
         .await