Implement sell=buy support for Sell orders

Justfile

@@ -22,8 +22,8 @@ test-e2e-local: (test-e2e "local_node")
 test-e2e-forked: (test-e2e "forked_node")
 
 # Run End-to-end tests with custom filters
-test-e2e *filters:
-    cargo nextest run -p e2e {{filters}} --test-threads 1 --failure-output final --run-ignored ignored-only
+test-e2e filters="" *extra="":
+    cargo nextest run -p e2e '{{filters}}' --test-threads 1 --failure-output final --run-ignored ignored-only {{extra}}
 
 test-driver:
     RUST_MIN_STACK=3145728 cargo nextest run -p driver --test-threads 1 --run-ignored ignored-only

crates/driver/src/boundary/liquidity/mod.rs

@@ -128,6 +128,10 @@ impl Fetcher {
         pairs: &HashSet<liquidity::TokenPair>,
         block: infra::liquidity::AtBlock,
     ) -> Result<Vec<liquidity::Liquidity>> {
+        if pairs.is_empty() {
+            return Ok(vec![]);
+        }
+
         let pairs = pairs
             .iter()
             .map(|pair| {

crates/driver/src/domain/quote.rs

@@ -16,10 +16,7 @@ use {
         util,
     },
     chrono::Utc,
-    std::{
-        collections::{HashMap, HashSet},
-        iter,
-    },
+    std::collections::{HashMap, HashSet},
 };
 
 /// A quote describing the expected outcome of an order.
@@ -91,7 +88,7 @@ impl Order {
         let liquidity = match solver.liquidity() {
             solver::Liquidity::Fetch => {
                 liquidity
-                    .fetch(&self.liquidity_pairs(), infra::liquidity::AtBlock::Recent)
+                    .fetch(&self.token_liquidity(), infra::liquidity::AtBlock::Recent)
                     .await
             }
             solver::Liquidity::Skip => Default::default(),
@@ -225,29 +222,23 @@ impl Order {
     }
 
     /// Returns the token pairs to fetch liquidity for.
-    fn liquidity_pairs(&self) -> HashSet<liquidity::TokenPair> {
-        let pair = liquidity::TokenPair::try_new(self.tokens.sell(), self.tokens.buy())
-            .expect("sell != buy by construction");
-        iter::once(pair).collect()
+    fn token_liquidity(&self) -> HashSet<liquidity::TokenPair> {
+        liquidity::TokenPair::try_new(self.tokens.sell(), self.tokens.buy())
+            .ok()
+            .into_iter()
+            .collect()
     }
 }
 
-/// The sell and buy tokens to quote for. This type maintains the invariant that
-/// the sell and buy tokens are distinct.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct Tokens {
     sell: eth::TokenAddress,
     buy: eth::TokenAddress,
 }
 
 impl Tokens {
-    /// Creates a new instance of [`Tokens`], verifying that the input buy and
-    /// sell tokens are distinct.
-    pub fn try_new(sell: eth::TokenAddress, buy: eth::TokenAddress) -> Result<Self, SameTokens> {
-        if sell == buy {
-            return Err(SameTokens);
-        }
-        Ok(Self { sell, buy })
+    pub fn new(sell: eth::TokenAddress, buy: eth::TokenAddress) -> Self {
+        Self { sell, buy }
     }
 
     pub fn sell(&self) -> eth::TokenAddress {

crates/driver/src/infra/api/routes/quote/dto/order.rs

@@ -8,17 +8,16 @@ use {
 };
 
 impl Order {
-    pub fn into_domain(self) -> Result<quote::Order, Error> {
-        Ok(quote::Order {
-            tokens: quote::Tokens::try_new(self.sell_token.into(), self.buy_token.into())
-                .map_err(|quote::SameTokens| Error::SameTokens)?,
+    pub fn into_domain(self) -> quote::Order {
+        quote::Order {
+            tokens: quote::Tokens::new(self.sell_token.into(), self.buy_token.into()),
             amount: self.amount.into(),
             side: match self.kind {
                 Kind::Sell => competition::order::Side::Sell,
                 Kind::Buy => competition::order::Side::Buy,
             },
             deadline: self.deadline,
-        })
+        }
     }
 }
 

crates/driver/src/infra/api/routes/quote/mod.rs

@@ -19,9 +19,7 @@ async fn route(
     order: axum::extract::Query<dto::Order>,
 ) -> Result<axum::Json<dto::Quote>, (hyper::StatusCode, axum::Json<Error>)> {
     let handle_request = async {
-        let order = order.0.into_domain().inspect_err(|err| {
-            observe::invalid_dto(err, "order");
-        })?;
+        let order = order.0.into_domain();
         observe::quoting(&order);
         let quote = order
             .quote(

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -17,10 +17,16 @@ use {
 
 #[tokio::test]
 #[ignore]
-async fn local_node_test() {
+async fn local_node_place_order_with_quote_basic() {
     run_test(place_order_with_quote).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_disabled_same_sell_and_buy_token_order_feature() {
+    run_test(disabled_same_sell_and_buy_token_order_feature).await;
+}
+
 async fn place_order_with_quote(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -112,3 +118,49 @@ async fn place_order_with_quote(web3: Web3) {
     assert_eq!(quote_response.verified, order_quote.verified);
     assert_eq!(quote_metadata.unwrap().0, order_quote.metadata);
 }
+
+async fn disabled_same_sell_and_buy_token_order_feature(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;
+
+    token.mint(trader.address(), 10u64.eth()).await;
+
+    token
+        .approve(onchain.contracts().allowance.into_alloy(), 10u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+    services.start_protocol(solver.clone()).await;
+
+    // Disable auto-mine so we don't accidentally mine a settlement
+    web3.api::<TestNodeApi<_>>()
+        .set_automine_enabled(false)
+        .await
+        .expect("Must be able to disable automine");
+
+    tracing::info!("Quoting");
+    let quote_sell_amount = 1u64.eth();
+    let quote_request = OrderQuoteRequest {
+        from: trader.address(),
+        sell_token: *token.address(),
+        buy_token: *token.address(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(quote_sell_amount).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+    assert!(
+        matches!(services.submit_quote(&quote_request).await, Err((reqwest::StatusCode::BAD_REQUEST, response)) if response.contains("SameBuyAndSellToken"))
+    );
+}