Settle fast-path quote solutions via the existing /settle by AryanGodara · Pull Request #4710 · cowprotocol/services

AryanGodara · 2026-08-06T14:34:12Z

Description

Completes the driver half of BE-58. A fast-path quote already caches its Solution (in #4678). This works on the /settle part. At settle time the driver re-encodes the cached solution against the real signed order and submits via the unchanged mempool path.

Changes

Added an optional real signed order and its native prices to /settle. When the order is present, the driver re-encodes the cached quote solution against it before the (unchanged) settle path submits.
Re-encoding reuses the quote's work instead of re-solving: it swaps the quote's placeholder order for the real signed order, keeps the cached route + clearing prices, and adds the native prices onto the auction's tokens so the settlement gets a slippage buffer.
The resulting settlement is cached by (auction_id, solution_id), so the existing /settle lookup + mempool submission consume it unchanged.

How to test

unit and e2e tests

linear-code · 2026-08-06T14:34:24Z

BE-58

github-actions · 2026-08-06T14:34:27Z

Reminder: Please consider backward compatibility when modifying the API specification.
If breaking changes are unavoidable, ensure:

You explicitly pointed out breaking changes.
You communicate the changes to affected teams (at least Frontend team and SAFE team).
You provide proper versioning and migration mechanisms.

Resolved

claude · 2026-08-06T15:00:31Z

Claude finished @AryanGodara's task in 5m 23s —— View job

PR Review — Settle fast-path quote solutions

The design is sound and, importantly, fail-safe: rebind_quote_order only swaps the order while keeping the cached route/prices, and Fulfillment::new re-validates executed_with_fee == order.target(), so a real order whose amounts/side/tokens/kind don't match the quote is rejected rather than mis-settled. The settle/reveal lookup keys on (auction_id, solution_id), which the re-encoded settlement inherits from the cached quote auction, so the existing mempool path consumes it unchanged. The solve_request.rs change is a clean extract-to-into_domain refactor with no behavior change. Nice test coverage for the happy path, missing-order, and mismatch cases.

Two minor points posted inline (silent dropping of invalid native prices → missing slippage buffer; and all fast-path failures collapsing into Kind::Unknown, hurting prod diagnosability). Both are non-blocking.

One item not inline-able (file not in diff):

crates/driver/openapi.yml — SettleRequest (around line 593) was not updated with the new optional order and prices fields. Given the API-change reminder on this PR, worth adding them (documented as optional / fast-path-only) so the spec stays in sync.

Nothing here blocks merge — the amount-mismatch guard makes the risky part safe. LGTM once the openapi doc is updated.

MartinquaXD

I'm positively surprised. A few things seem more complicated than they need to and some edge cases are not handled but overall the approach seems relatively non invasive. 👍

MartinquaXD · 2026-08-06T15:06:59Z

+            .cloned()
+            .ok_or(Error::SolutionNotAvailable)?;
+        let solution = cached.solution.rebind_quote_order(order.clone())?;
+        let tokens = Arc::new(cached.auction.tokens.with_native_prices(&prices));


The cached solution already has the necessary native prices. I think they should probably not be updated.

I might've misunderstood this part. I had the confusion that is clearing prices vs native prices. the cached solution has the solver's clearing prices, but the driver's quote path never receives native prices (unlike /solve, the /quote request seems to carry None and there's no estimator in the driver), so cached.auction.native_prices() is empty apart fromfor ETH.
The prices on /settle is the only thing that sizes the slippage buffer by native value.

If I'm not incorrect 👆🏼 then maybe we can also have the orderbok send native prices on the quote request, so we can cache them in as well. You call 👀

Hmm, you are right. Sending the native prices in the quote request is cleaner but can also incur a latency hit because we'd then have to resolve the native price before we can send the quote request. Also we'd have to update a bunch of interfaces.
Let's keep the native prices in the /settle request for now but I suspect before the final release we should pivot to native prices in the quote request.

MartinquaXD · 2026-08-06T15:40:26Z

    async move {
        observe::settling();
+        if let Some(order) = req.order {
+            let app_data = AppData::Hash(AppDataHash::from(order.app_data));


It looks like the appdata is not handled sufficiently. In practice the order will be placed with an appdata hash that the driver did not resolve yet. When reencoding the solution the driver has to use the appdata cache to either look up the full appdata or fetch it from the API just in time.

I'm thinking of doing this separately (since this'll also contain handling pre/post hooks, flashloans, etc). I'm thinking of doing this on a stacked PR on top of this one to keep things clean and isolated. (Or maybe I'm overthinking this 🤷🏼 )

update: decided to just do it here 😅

…rappers

MartinquaXD

Things are more complicated than I thought. Will have to think more about it and do another pass tomorrow.

MartinquaXD · 2026-08-06T21:27:44Z

-            return Err(error::Error::FastPathOrderMismatch);
-        }
-        *user = user.with_order(order)?;
+        let (flashloans, wrappers) = {


doesn't seem like the extra scope helps here TBH. This also causes you to mix validation logic with the actual work the function does.

MartinquaXD · 2026-08-06T21:29:50Z

+            let flashloans = order
+                .app_data
+                .flashloan()
+                .filter(|_| flashloans_enabled)


the config flag feeding this boolean controls whether flashloan hints should be sent to the solver. In this case we are already able to resolve the flashloan and the order will not work without it.

MartinquaXD · 2026-08-06T21:31:31Z

-    pub fn rebind_quote_order(&self, order: competition::Order) -> Result<Self, error::Error> {
+    /// `order`, keeping the cached route and clearing prices, and recover the
+    /// order's flashloans/wrappers from its app-data.
+    pub fn rebind_quote_order(


I still think the name isn't really helpful here.
WDYT about finalize_fast_path_solution()?

MartinquaXD · 2026-08-06T21:39:59Z

        observe::settling();
        if let Some(order) = req.order {
-            let app_data = AppData::Hash(AppDataHash::from(order.app_data));
+            let app_data = state


There should not be a lot of code inside the API request handlers. Ideally they are only used to define the REST API and dispatch to the business logic. Let's try to clean this up a bit. Looks like you could turn all this into 1 public function on the competition struct that in turn calls a few private functions.
The whole logic that turns a cached solution into a fully encode solution is a bit hard to follow at the moment.

MartinquaXD · 2026-08-06T21:46:41Z

+                    Trade::Fulfillment(fulfillment) => Some(fulfillment),
+                    Trade::Jit(_) => None,
+                })
+                .expect("exactly one user trade counted above");


you can avoid this expect and simplify the error handling above by using Itertools:

let Ok(user_trade) = self.user_trades().exactly_one() else { // error about unexpected number of user trades };

MartinquaXD · 2026-08-06T21:57:52Z

+    pub async fn resolve_app_data(
+        &self,
+        hash: &order::app_data::AppDataHash,
+    ) -> Option<Arc<app_data::ValidatedAppData>> {


You are adding a purpose built function here which has an API that's so generic that it's not very useful for the 1 caller it has.
I think an API like this would be much nicer:

/// Resolves the order's appdata hash to the underlying JSON if it isn't already. pub async fn resolve_app_data( &self, order: &mut Order, )

MartinquaXD · 2026-08-06T21:58:33Z

        }
    }

+    pub async fn resolve_app_data(


This function does not have to exist if you move the logic that currently happens in the REST API handler into the competition struct.

MartinquaXD · 2026-08-06T22:02:36Z

+            .cloned()
+            .ok_or(Error::SolutionNotAvailable)?;
+        let solution = cached.solution.rebind_quote_order(order.clone())?;
+        let tokens = Arc::new(cached.auction.tokens.with_native_prices(&prices));


Hmm, you are right. Sending the native prices in the quote request is cleaner but can also incur a latency hit because we'd then have to resolve the native price before we can send the quote request. Also we'd have to update a bunch of interfaces.
Let's keep the native prices in the /settle request for now but I suspect before the final release we should pivot to native prices in the quote request.

MartinquaXD · 2026-08-06T22:15:17Z

+                quoted.sell.token,
+                quoted.buy.token,
+                quoted.side,
+                quoted.target(),


Checking for quality in the target amount is probably okay.
However, we also need to check that the amount we need to provide is <= what we originally computed. Also it's not enough to just provide the user order as is in the /settle endpoint we also need to provide that limit price the solver has to fulfill. The reason is that the user will apply some slippage to the order amounts but during the fast path order should get filled at the originally quoted amount - not just the order's limit price.

So by now we have 3 pieces of data that normally don't exist in the settle path:

order

limit prices

native price

Since all of those are only populated in the fast path case they should also be bundled together in the settle POST body.

AryanGodara added 6 commits July 28, 2026 17:54

cache fast-path quote solutions in the driver

13bdda9

Merge branch 'main' into aryan/be-58-cache-quote-solutions

a156e8a

address claude bot comments

ffda40e

Merge branch 'main' into aryan/be-58-cache-quote-solutions

46801e7

address review comments

a2b4f96

Merge branch 'main' into aryan/be-58-cache-quote-solutions

c61b07f

AryanGodara self-assigned this Aug 6, 2026

AryanGodara changed the base branch from main to aryan/be-58-cache-quote-solutions August 6, 2026 14:34

AryanGodara added 2 commits August 6, 2026 20:05

Merge branch 'main' into aryan/be-58-cache-quote-solutions

1bd6fe7

settle fast-path quote solutions via the existing /settle

1b8d082

AryanGodara force-pushed the aryan/be-58-settle-fastpath-quote branch from ad645bf to 1b8d082 Compare August 6, 2026 14:41

AryanGodara marked this pull request as ready for review August 6, 2026 14:59

AryanGodara requested a review from a team as a code owner August 6, 2026 14:59

claude Bot reviewed Aug 6, 2026

View reviewed changes

Comment thread crates/driver/src/infra/api/routes/settle/mod.rs Outdated

claude Bot reviewed Aug 6, 2026

View reviewed changes

Comment thread crates/driver/src/infra/api/error.rs

MartinquaXD reviewed Aug 6, 2026

View reviewed changes

AryanGodara added 2 commits August 7, 2026 00:18

address review comments

a256508

resolve order app-data at settle and re-derive fast-path flashloans/w…

258e7b1

…rappers

AryanGodara requested a review from MartinquaXD August 6, 2026 19:56

MartinquaXD reviewed Aug 6, 2026

View reviewed changes

Base automatically changed from aryan/be-58-cache-quote-solutions to main August 7, 2026 14:06

Uh oh!

Conversation

AryanGodara commented Aug 6, 2026

Description

Changes

How to test

Uh oh!

linear-code Bot commented Aug 6, 2026

Uh oh!

github-actions Bot commented Aug 6, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

claude Bot commented Aug 6, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

PR Review — Settle fast-path quote solutions

Uh oh!

Uh oh!

Uh oh!

MartinquaXD left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MartinquaXD left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

github-actions Bot commented Aug 6, 2026 •

edited

Loading

claude Bot commented Aug 6, 2026 •

edited

Loading