Custom order simulation

crates/e2e/tests/e2e/order_simulation.rs

@@ -1,4 +1,5 @@
 use {
+    alloy::{primitives::Address, providers::Provider},
     configs::test_util::TestDefault,
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     ethrpc::{Web3, alloy::CallBuilderExt},
@@ -9,6 +10,7 @@ use {
     number::units::EthUnit,
     orderbook::dto::OrderSimulationResult,
     reqwest::StatusCode,
+    serde_json::json,
     simulator::tenderly::dto::SimulationType,
 };
 
@@ -18,6 +20,86 @@ async fn local_node_order_simulation() {
     run_test(order_simulation).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_order_simulation_block_number() {
+    run_test(order_simulation_block_number).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_custom_order_simulation() {
+    run_test(custom_order_simulation).await;
+}
+
+async fn custom_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(1u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    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 client = services.client();
+    let sell_amount = 1u64.eth();
+
+    let body = json!({
+        "sellToken": token.address(),
+        "buyToken": onchain.contracts().weth.address(),
+        "sellAmount": sell_amount.to_string(),
+        "buyAmount": "1",
+        "kind": "sell",
+        "owner": trader.address(),
+    });
+
+    // Trader has no sell tokens — simulation should revert.
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&body)
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_some(),
+        "expected simulation error when trader has no funds"
+    );
+
+    // Fund the trader and approve the vault relayer.
+    token.mint(trader.address(), sell_amount).await;
+    token
+        .approve(onchain.contracts().allowance, sell_amount)
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Simulation should now succeed.
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&body)
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_none(),
+        "expected simulation to pass after funding the trader"
+    );
+}
+
 async fn order_simulation(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -87,3 +169,115 @@ async fn order_simulation(web3: Web3) {
     assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
     assert_eq!(tenderly.value, None);
 }
+
+async fn order_simulation_block_number(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;
+
+    // Fund trader so the order passes balance validation at submission time.
+    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();
+
+    // Transfer all WETH away from the trader — now they have no sell-token
+    // balance. The current block becomes the "no funds" snapshot.
+    let burn = Address::from([0x42u8; 20]);
+    onchain
+        .contracts()
+        .weth
+        .transfer(burn, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+    let block_no_funds = web3.provider.get_block_number().await.unwrap();
+
+    // Re-deposit WETH. The current block now has the trader fully funded again.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    let block_with_funds = web3.provider.get_block_number().await.unwrap();
+
+    let client = services.client();
+
+    // Simulation at the block where the trader had no WETH must fail.
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_no_funds}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_some(),
+        "expected simulation failure at block {block_no_funds} (no funds), got success"
+    );
+
+    // Simulation at the block where the trader has WETH must succeed.
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_with_funds}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert_eq!(
+        result.error, None,
+        "expected simulation success at block {block_with_funds} (funded), got error: {:?}",
+        result.error
+    );
+}

crates/orderbook/Cargo.toml

@@ -33,6 +33,7 @@ configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
+eth-domain-types = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }

crates/orderbook/openapi.yml

@@ -765,6 +765,31 @@ paths:
                 $ref: "#/components/schemas/TotalSurplus"
         "400":
           description: Invalid address.
+  "/api/v1/debug/simulation":
+    post:
+      operationId: debugSimulationPost
+      summary: Simulate an arbitrary order.
+      description: >
+        Simulates an arbitrary order specified in the request body and returns
+        the Tenderly simulation request, along with any simulation error if
+        applicable.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SimulationRequest"
+      responses:
+        "200":
+          description: Simulation request returned.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/OrderSimulation"
+        "405":
+          description: Order simulation endpoint is not enabled.
+        "500":
+          description: Internal error.
   "/api/v1/debug/simulation/{uid}":
     get:
       operationId: debugSimulation
@@ -778,6 +803,15 @@ paths:
           schema:
             $ref: "#/components/schemas/UID"
           required: true
+        - in: query
+          name: block_number
+          schema:
+            type: integer
+            format: int64
+          required: false
+          description: >
+            Block number to simulate the order at. If not specified, the
+            simulation uses the latest block.
       responses:
         "200":
           description: Simulation request returned.
@@ -2650,6 +2684,79 @@ components:
         - from
         - to
         - input
+    SimulationRequest:
+      description: >
+        Request body for simulating an arbitrary order without it being stored
+        in the orderbook.
+      type: object
+      properties:
+        sellToken:
+          description: The token being sold.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        buyToken:
+          description: The token being bought.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        sellAmount:
+          description: Amount of sell token (hex- or decimal-encoded uint256).
+          allOf:
+            - $ref: "#/components/schemas/TokenAmount"
+        buyAmount:
+          description: Amount of buy token (hex- or decimal-encoded uint256).
+          allOf:
+            - $ref: "#/components/schemas/TokenAmount"
+        kind:
+          description: Whether this is a sell or buy order.
+          allOf:
+            - $ref: "#/components/schemas/OrderKind"
+        owner:
+          description: The address of the order owner.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        receiver:
+          description: >
+            The address that will receive the buy tokens. Defaults to the owner
+            if omitted.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+          nullable: true
+        sellTokenBalance:
+          description: Where the sell token should be drawn from.
+          allOf:
+            - $ref: "#/components/schemas/SellTokenSource"
+          default: erc20
+        buyTokenBalance:
+          description: Where the buy token should be transferred to.
+          allOf:
+            - $ref: "#/components/schemas/BuyTokenDestination"
+          default: erc20
+        appData:
+          description: >
+            Full app data JSON string. Defaults to `"{}"` if omitted.
+          type: string
+          nullable: true
+        interactions:
+          description: Pre- and post-trade interactions for the order.
+          type: object
+          properties:
+            pre:
+              description: Interactions executed before the order's trade.
+              type: array
+              items:
+                $ref: "#/components/schemas/InteractionData"
+            post:
+              description: Interactions executed after the order's trade.
+              type: array
+              items:
+                $ref: "#/components/schemas/InteractionData"
+      required:
+        - sellToken
+        - buyToken
+        - sellAmount
+        - buyAmount
+        - kind
+        - owner
     OrderSimulation:
       description: >
         The Tenderly simulation request for an order, along with any

crates/orderbook/src/api.rs

@@ -271,6 +271,11 @@ pub fn handle_all_routes(
             "/api/v1/debug/simulation/{uid}",
             get(debug_simulation::debug_simulation_handler),
         ),
+        (
+            "POST",
+            "/api/v1/debug/simulation",
+            post(debug_simulation::debug_simulation_post_handler),
+        ),
         // V2 routes
         // /solver_competition routes (specific before parameterized)
         (