Reimplement sell=buy PoC PR

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/domain/quote.rs

@@ -17,10 +17,7 @@ use {
     },
     chrono::Utc,
     ethrpc::alloy::conversions::IntoLegacy,
-    std::{
-        collections::{HashMap, HashSet},
-        iter,
-    },
+    std::collections::{HashMap, HashSet},
 };
 
 /// A quote describing the expected outcome of an order.
@@ -91,13 +88,13 @@ impl Order {
         liquidity: &infra::liquidity::Fetcher,
         tokens: &infra::tokens::Fetcher,
     ) -> Result<Quote, Error> {
-        let liquidity = match solver.liquidity() {
-            solver::Liquidity::Fetch => {
+        let liquidity = match (solver.liquidity(), self.token_liquidity()) {
+            (solver::Liquidity::Fetch, pairs) if !pairs.is_empty() => {
                 liquidity
-                    .fetch(&self.liquidity_pairs(), infra::liquidity::AtBlock::Recent)
+                    .fetch(&pairs, infra::liquidity::AtBlock::Recent)
                     .await
             }
-            solver::Liquidity::Skip => Default::default(),
+            _ => Default::default(),
         };
 
         let auction = self
@@ -226,29 +223,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

@@ -19,10 +19,22 @@ 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_place_order_with_quote_same_token_pair() {
+    run_test(place_order_with_quote_same_token_pair).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_place_order_with_quote_same_token_pair_error() {
+    run_test(place_order_with_quote_same_token_pair_error).await;
+}
+
 async fn place_order_with_quote(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -114,3 +126,138 @@ 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 place_order_with_quote_same_token_pair_error(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(to_wei(10).into_alloy()).await;
+    let [trader] = onchain.make_accounts(to_wei(10).into_alloy()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000))
+        .await;
+
+    token.mint(trader.address(), eth(10)).await;
+
+    token
+        .approve(onchain.contracts().allowance.into_alloy(), eth(10))
+        .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 = to_wei(1);
+    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"))
+    );
+}
+
+async fn place_order_with_quote_same_token_pair(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(eth(10)).await;
+    let [trader] = onchain.make_accounts(eth(10)).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000))
+        .await;
+
+    token.mint(trader.address(), eth(10)).await;
+
+    token
+        .approve(onchain.contracts().allowance.into_alloy(), eth(10))
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs {
+                api: vec!["--allow-same-sell-and-buy-token=true".to_string()],
+                ..Default::default()
+            },
+            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 = to_wei(1);
+    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()
+    };
+    let quote_response = services.submit_quote(&quote_request).await.unwrap();
+    tracing::debug!(?quote_response);
+    assert!(quote_response.id.is_some());
+    assert!(quote_response.verified);
+
+    let quote_metadata =
+        crate::database::quote_metadata(services.db(), quote_response.id.unwrap()).await;
+    assert!(quote_metadata.is_some());
+    tracing::debug!(?quote_metadata);
+
+    tracing::info!("Placing order");
+    let order = OrderCreation {
+        quote_id: quote_response.id,
+        sell_token: token.address().into_legacy(),
+        sell_amount: quote_sell_amount,
+        buy_token: token.address().into_legacy(),
+        buy_amount: quote_response.quote.buy_amount.into_legacy(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Sell,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()),
+    );
+    let order_uid = services.create_order(&order).await.unwrap();
+
+    tracing::info!("Order quote verification");
+    let order_quote = database::orders::read_quote(
+        services.db().acquire().await.unwrap().deref_mut(),
+        &database::byte_array::ByteArray(order_uid.0),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(quote_response.verified, order_quote.verified);
+    assert_eq!(quote_metadata.unwrap().0, order_quote.metadata);
+}