Do not count "in-market" orders for the order limit #2433

crates/database/src/orders.rs

@@ -716,6 +716,45 @@ pub async fn count_limit_orders_by_owner(
         .await
 }
 
+#[derive(Debug, sqlx::FromRow)]
+pub struct OrderWithQuote {
+    pub order_buy_amount: BigDecimal,
+    pub order_sell_amount: BigDecimal,
+    pub order_fee_amount: BigDecimal,
+    pub quote_buy_amount: BigDecimal,
+    pub quote_sell_amount: BigDecimal,
+    pub quote_gas_amount: f64,
+    pub quote_gas_price: f64,
+    pub quote_sell_token_price: f64,
+}
+
+pub async fn user_orders_with_quote(
+    ex: &mut PgConnection,
+    min_valid_to: i64,
+    owner: &Address,
+) -> Result<Vec<OrderWithQuote>, sqlx::Error> {
+    #[rustfmt::skip]
+    const QUERY: &str = const_format::concatcp!(
+        "SELECT o_quotes.sell_amount as quote_sell_amount, o.sell_amount as order_sell_amount,",
+        " o_quotes.buy_amount as quote_buy_amount, o.buy_amount as order_buy_amount,",
+        " o.fee_amount as order_fee_amount, o_quotes.gas_amount as quote_gas_amount,",
+        " o_quotes.gas_price as quote_gas_price, o_quotes.sell_token_price as quote_sell_token_price",
+        " FROM order_quotes o_quotes",
+        " LEFT JOIN (",
+            " SELECT *",
+            " FROM (", OPEN_ORDERS,
+            " AND owner = $2",
+            " AND class = 'limit'",
+            " ) AS subquery",
+        " ) AS o ON o_quotes.order_uid = o.uid"
+    );
+    sqlx::query_as::<_, OrderWithQuote>(QUERY)
+        .bind(min_valid_to)
+        .bind(owner)
+        .fetch_all(ex)
+        .await
+}
+
 #[cfg(test)]
 mod tests {
     use {

crates/e2e/tests/e2e/limit_orders.rs

@@ -1,5 +1,6 @@
 use {
     contracts::ERC20,
+    driver::domain::eth::NonZeroU256,
     e2e::{nodes::forked_node::ForkedNodeApi, setup::*, tx},
     ethcontract::{prelude::U256, H160},
     model::{
@@ -30,6 +31,12 @@ async fn local_node_too_many_limit_orders() {
     run_test(too_many_limit_orders_test).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_limit_does_not_apply_to_in_market_orders_test() {
+    run_test(limit_does_not_apply_to_in_market_orders_test).await;
+}
+
 #[tokio::test]
 #[ignore]
 async fn local_node_mixed_limit_and_market_orders() {
@@ -483,6 +490,129 @@ async fn too_many_limit_orders_test(web3: Web3) {
         &onchain.contracts().domain_separator,
         SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()),
     );
+
+    let (status, body) = services.create_order(&order).await.unwrap_err();
+    assert_eq!(status, 400);
+    assert!(body.contains("TooManyLimitOrders"));
+}
+
+async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(to_wei(1)).await;
+    let [trader] = onchain.make_accounts(to_wei(1)).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(100)).await;
+
+    // Approve GPv2 for trading
+    tx!(
+        trader.account(),
+        token.approve(onchain.contracts().allowance, to_wei(101))
+    );
+
+    // Place Orders
+    let services = Services::new(onchain.contracts()).await;
+    let solver_endpoint =
+        colocation::start_baseline_solver(onchain.contracts().weth.address()).await;
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![colocation::SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
+    services
+        .start_api(vec![
+            "--max-limit-orders-per-user=1".into(),
+            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
+        ])
+        .await;
+
+    let quote_request = OrderQuoteRequest {
+        from: trader.address(),
+        sell_token: token.address(),
+        buy_token: onchain.contracts().weth.address(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(to_wei(5)).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+    let quote = services.submit_quote(&quote_request).await.unwrap();
+
+    // Place "in-market" order
+    let order = OrderCreation {
+        sell_token: token.address(),
+        sell_amount: quote.quote.sell_amount,
+        buy_token: onchain.contracts().weth.address(),
+        buy_amount: quote.quote.buy_amount.saturating_sub(to_wei(4)),
+        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());
+
+    // Place a "limit" order
+    let order = OrderCreation {
+        sell_token: token.address(),
+        sell_amount: to_wei(1),
+        buy_token: onchain.contracts().weth.address(),
+        buy_amount: to_wei(3),
+        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_id = services.create_order(&order).await.unwrap();
+    let limit_order = services.get_order(&order_id).await.unwrap();
+    assert!(limit_order.metadata.class.is_limit());
+
+    // Place another "in-market" order in order to check it is not limited
+    let order = OrderCreation {
+        sell_token: token.address(),
+        sell_amount: quote.quote.sell_amount,
+        buy_token: onchain.contracts().weth.address(),
+        buy_amount: quote.quote.buy_amount.saturating_sub(to_wei(2)),
+        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());
+
+    // Place a "limit" order in order to see if fails
+    let order = OrderCreation {
+        sell_token: token.address(),
+        sell_amount: to_wei(1),
+        buy_token: onchain.contracts().weth.address(),
+        buy_amount: to_wei(2),
+        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 (status, body) = services.create_order(&order).await.unwrap_err();
     assert_eq!(status, 400);
     assert!(body.contains("TooManyLimitOrders"));

crates/orderbook/src/database/orders.rs

@@ -44,8 +44,9 @@ use {
             signing_scheme_from,
             signing_scheme_into,
         },
+        fee::FeeParameters,
         order_quoting::Quote,
-        order_validation::LimitOrderCounting,
+        order_validation::{is_order_outside_market_price, Amounts, LimitOrderCounting},
     },
     sqlx::{types::BigDecimal, Connection, PgConnection},
     std::convert::TryInto,
@@ -374,12 +375,33 @@ impl LimitOrderCounting for Postgres {
             .start_timer();
 
         let mut ex = self.pool.acquire().await?;
-        Ok(database::orders::count_limit_orders_by_owner(
+        Ok(database::orders::user_orders_with_quote(
             &mut ex,
             now_in_epoch_seconds().into(),
             &ByteArray(owner.0),
         )
         .await?
+        .into_iter()
+        .filter(|order_with_quote| {
+            is_order_outside_market_price(
+                &Amounts {
+                    sell: big_decimal_to_u256(&order_with_quote.order_sell_amount).unwrap(),
+                    buy: big_decimal_to_u256(&order_with_quote.order_buy_amount).unwrap(),
+                    fee: big_decimal_to_u256(&order_with_quote.order_fee_amount).unwrap(),
+                },
+                &Amounts {
+                    sell: big_decimal_to_u256(&order_with_quote.quote_sell_amount).unwrap(),
+                    buy: big_decimal_to_u256(&order_with_quote.quote_buy_amount).unwrap(),
+                    fee: FeeParameters {
+                        gas_amount: order_with_quote.quote_gas_amount,
+                        gas_price: order_with_quote.quote_gas_price,
+                        sell_token_price: order_with_quote.quote_sell_token_price,
+                    }
+                    .fee(),
+                },
+            )
+        })
+        .count()
         .try_into()
         .unwrap())
     }