Refactor Route and sell=buy validation control

Author: m-sz

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.
@@ -92,7 +89,7 @@ impl Order {
         tokens: &infra::tokens::Fetcher,
     ) -> Result<Quote, Error> {
         let liquidity = match (solver.liquidity(), self.token_liquidity()) {
-            (solver::Liquidity::Fetch, Some(pairs)) => {
+            (solver::Liquidity::Fetch, pairs) if !pairs.is_empty() => {
                 liquidity
                     .fetch(&pairs, infra::liquidity::AtBlock::Recent)
                     .await
@@ -226,10 +223,11 @@ impl Order {
     }
 
     /// Returns the token pairs to fetch liquidity for.
-    fn token_liquidity(&self) -> Option<HashSet<liquidity::TokenPair>> {
+    fn token_liquidity(&self) -> HashSet<liquidity::TokenPair> {
         liquidity::TokenPair::try_new(self.tokens.sell(), self.tokens.buy())
-            .map(|pair| iter::once(pair).collect())
             .ok()
+            .into_iter()
+            .collect()
     }
 }
 

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -168,7 +168,9 @@ async fn place_order_with_quote_same_token_pair_error(web3: Web3) {
         },
         ..Default::default()
     };
-    assert!(services.submit_quote(&quote_request).await.is_err());
+    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) {

crates/e2e/tests/e2e/submission.rs

@@ -19,10 +19,28 @@ use {
 
 #[tokio::test]
 #[ignore]
-async fn local_node_test() {
+async fn local_node_on_expiry() {
     run_test(test_cancel_on_expiry).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_execute_same_sell_and_buy_token() {
+    run_test(test_execute_same_sell_and_buy_token).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_submit_same_sell_and_buy_token_order_without_quote() {
+    run_test(test_submit_same_sell_and_buy_token_order_without_quote).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_submit_same_sell_and_buy_token_order_without_quote_fail() {
+    run_test(test_submit_same_sell_and_buy_token_order_without_quote_fail).await;
+}
+
 async fn test_cancel_on_expiry(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -123,6 +141,222 @@ async fn test_cancel_on_expiry(web3: Web3) {
     assert_eq!(tx.to, Some(solver.account().address()))
 }
 
+async fn test_submit_same_sell_and_buy_token_order_without_quote(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!("Placing order");
+    let order = OrderCreation {
+        sell_token: token.address().into_legacy(),
+        sell_amount: to_wei(1),
+        buy_token: token.address().into_legacy(),
+        buy_amount: to_wei(1),
+        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()),
+    );
+    services.create_order(&order).await.unwrap();
+}
+
+async fn test_submit_same_sell_and_buy_token_order_without_quote_fail(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(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!("Placing order");
+    let order = OrderCreation {
+        sell_token: token.address().into_legacy(),
+        sell_amount: to_wei(1),
+        buy_token: token.address().into_legacy(),
+        buy_amount: to_wei(1),
+        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()),
+    );
+    // services.create_order(&order).await.unwrap();
+    assert!(
+        matches!(services.create_order(&order).await, Err((reqwest::StatusCode::BAD_REQUEST, response)) if response.contains("SameBuyAndSellToken"))
+    );
+}
+
+async fn test_execute_same_sell_and_buy_token(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!("Placing order");
+    let initial_balance = token.balanceOf(trader.address()).call().await.unwrap();
+    assert_eq!(initial_balance, eth(10));
+
+    let order_sell_amount = to_wei(2);
+    let order_buy_amount = to_wei(1);
+    let order = OrderCreation {
+        sell_token: token.address().into_legacy(),
+        sell_amount: order_sell_amount,
+        buy_token: token.address().into_legacy(),
+        buy_amount: order_buy_amount,
+        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()),
+    );
+    assert!(services.create_order(&order).await.is_ok());
+
+    // Start tracking confirmed blocks so we can find the transaction later
+    let block_stream = web3
+        .eth_filter()
+        .create_blocks_filter()
+        .await
+        .expect("must be able to create blocks filter")
+        .stream(Duration::from_millis(50));
+
+    tracing::info!("Waiting for trade.");
+    onchain.mint_block().await;
+
+    // Wait for settlement tx to appear in txpool
+    wait_for_condition(Duration::from_secs(2), || async {
+        get_pending_tx(solver.account().address(), &web3)
+            .await
+            .is_some()
+    })
+    .await
+    .unwrap();
+
+    // Continue mining to confirm the settlement
+    web3.api::<TestNodeApi<_>>()
+        .set_automine_enabled(true)
+        .await
+        .expect("Must be able to enable automine");
+
+    // Wait for the settlement to be confirmed on chain
+    let tx = tokio::time::timeout(
+        Duration::from_secs(5),
+        get_confirmed_transaction(solver.account().address(), &web3, block_stream),
+    )
+    .await
+    .unwrap();
+
+    // Verify the transaction is to the settlement contract (not a cancellation)
+    assert_eq!(
+        tx.to,
+        Some(onchain.contracts().gp_settlement.address().into_legacy())
+    );
+
+    // Verify that the balance changed (settlement happened on chain)
+    let trade_happened = || async {
+        let balance = token.balanceOf(trader.address()).call().await.unwrap();
+        // Balance should change due to fees even if sell token == buy token
+        balance != initial_balance
+    };
+    wait_for_condition(TIMEOUT, trade_happened).await.unwrap();
+
+    let final_balance = token.balanceOf(trader.address()).call().await.unwrap();
+    tracing::info!(?initial_balance, ?final_balance, "Trade completed");
+
+    // Verify that the balance changed (settlement happened on chain)
+    assert_ne!(final_balance, initial_balance);
+}
+
 async fn get_pending_tx(account: H160, web3: &Web3) -> Option<web3::types::Transaction> {
     let txpool = web3
         .txpool()

crates/orderbook/src/run.rs

@@ -403,6 +403,7 @@ pub async fn run(args: Arguments) {
         .ok();
     let order_validator = Arc::new(
         OrderValidator::new(
+            native_token,
             Arc::new(order_validation::banned::Users::new(
                 chainalysis_oracle,
                 args.banned_users,
@@ -421,9 +422,7 @@ pub async fn run(args: Arguments) {
             app_data_validator.clone(),
             args.max_gas_per_order,
         )
-        .with_sell_and_buy_validation(
-            (!args.allow_same_sell_and_buy_token).then(|| native_token.clone()),
-        ),
+        .with_allow_same_sell_and_buy_token(args.allow_same_sell_and_buy_token),
     );
     let ipfs = args
         .ipfs_gateway