Feature flag for sell=buy

Author: m-sz

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -29,6 +29,12 @@ 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;
 
@@ -125,7 +131,7 @@ async fn place_order_with_quote(web3: Web3) {
     assert_eq!(quote_metadata.unwrap().0, order_quote.metadata);
 }
 
-async fn place_order_with_quote_same_token_pair(web3: Web3) {
+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)).await;
@@ -147,6 +153,58 @@ async fn place_order_with_quote_same_token_pair(web3: Web3) {
     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().into_legacy(),
+        buy_token: token.address().into_legacy(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(quote_sell_amount).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+    assert!(services.submit_quote(&quote_request).await.is_err());
+}
+
+async fn place_order_with_quote_same_token_pair(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(to_wei(10)).await;
+    let [trader] = onchain.make_accounts(to_wei(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(), to_wei(10)).await;
+
+    token
+        .approve(onchain.contracts().allowance.into_alloy(), eth(10))
+        .from(trader.address().into_alloy())
+        .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)

crates/orderbook/src/api/post_order.rs

@@ -72,6 +72,13 @@ impl IntoWarpReply for PartialValidationErrorWrapper {
                 ),
                 StatusCode::BAD_REQUEST,
             ),
+            PartialValidationError::SameBuyAndSellToken => with_status(
+                error(
+                    "SameBuyAndSellToken",
+                    "Buy token is the same as the sell token.",
+                ),
+                StatusCode::BAD_REQUEST,
+            ),
             PartialValidationError::UnsupportedToken { token, reason } => with_status(
                 error(
                     "UnsupportedToken",

crates/orderbook/src/arguments.rs

@@ -141,6 +141,10 @@ pub struct Arguments {
     /// whether an order is actively being bid on.
     #[clap(long, env, default_value = "5")]
     pub active_order_competition_threshold: u32,
+
+    /// Allow same sell and buy token
+    #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
+    pub allow_same_sell_and_buy_token: bool,
 }
 
 impl std::fmt::Display for Arguments {
@@ -172,6 +176,7 @@ impl std::fmt::Display for Arguments {
             db_read_url,
             max_gas_per_order,
             active_order_competition_threshold,
+            allow_same_sell_and_buy_token,
         } = self;
 
         write!(f, "{shared}")?;
@@ -225,6 +230,10 @@ impl std::fmt::Display for Arguments {
             f,
             "active_order_competition_threshold: {active_order_competition_threshold}"
         )?;
+        writeln!(
+            f,
+            "allow_same_sell_and_buy_token: {allow_same_sell_and_buy_token}"
+        )?;
 
         Ok(())
     }

crates/orderbook/src/run.rs

@@ -409,25 +409,30 @@ pub async fn run(args: Arguments) {
     let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.alloy)
         .await
         .ok();
-    let order_validator = Arc::new(OrderValidator::new(
-        Arc::new(order_validation::banned::Users::new(
-            chainalysis_oracle,
-            args.banned_users,
-            args.banned_users_max_cache_size.get().to_u64().unwrap(),
-        )),
-        validity_configuration,
-        args.eip1271_skip_creation_validation,
-        bad_token_detector.clone(),
-        hooks_contract,
-        optimal_quoter.clone(),
-        balance_fetcher,
-        signature_validator,
-        Arc::new(postgres_write.clone()),
-        args.max_limit_orders_per_user,
-        code_fetcher,
-        app_data_validator.clone(),
-        args.max_gas_per_order,
-    ));
+    let order_validator = Arc::new(
+        OrderValidator::new(
+            Arc::new(order_validation::banned::Users::new(
+                chainalysis_oracle,
+                args.banned_users,
+                args.banned_users_max_cache_size.get().to_u64().unwrap(),
+            )),
+            validity_configuration,
+            args.eip1271_skip_creation_validation,
+            bad_token_detector.clone(),
+            hooks_contract,
+            optimal_quoter.clone(),
+            balance_fetcher,
+            signature_validator,
+            Arc::new(postgres_write.clone()),
+            args.max_limit_orders_per_user,
+            code_fetcher,
+            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()),
+        ),
+    );
     let ipfs = args
         .ipfs_gateway
         .map(|url| {