Merge branch 'cowprotocol:main' into main

Author: xdecentralix

crates/autopilot/src/database/mod.rs

@@ -139,7 +139,14 @@ struct Metrics {
     unused_app_data: prometheus::IntGauge,
 
     /// Timing of db queries.
-    #[metric(name = "autopilot_database_queries", labels("type"))]
+    #[metric(
+        name = "autopilot_database_queries",
+        labels("type"),
+        buckets(
+            0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0,
+            60.0, 70.0, 80.0, 90.0
+        )
+    )]
     database_queries: prometheus::HistogramVec,
 
     /// Number of active connections in the database pool.

crates/contracts/artifacts/SimulateCode.json

@@ -1944,7 +1944,6 @@ fn main() {
             .add_network_str(GNOSIS, "0x8262d639c38470F38d2eff15926F7071c28057Af")
             .add_network_str(SEPOLIA, "0x8262d639c38470F38d2eff15926F7071c28057Af")
     });
-    generate_contract("SimulateCode");
 
     // Support contract used for solver fee simulations.
     generate_contract("AnyoneAuthenticator");

crates/contracts/build.rs

@@ -12,7 +12,6 @@ CONTRACTS := \
 	Balances.sol \
 	Multicall.sol \
 	Signatures.sol \
-	SimulateCode.sol \
 	Solver.sol \
 	Spardose.sol \
 	Swapper.sol \

crates/contracts/solidity/Makefile

@@ -38,7 +38,6 @@ mod macros;
 
 #[cfg(feature = "bin")]
 pub mod paths;
-pub mod storage_accessible;
 pub mod vault;
 pub mod web3;
 
@@ -135,7 +134,6 @@ pub mod support {
         Balances;
         Multicall;
         Signatures;
-        SimulateCode;
         Solver;
         Spardose;
         Swapper;

crates/contracts/solidity/SimulateCode.sol

@@ -705,23 +705,104 @@ WHERE
 /// - pending pre-signature
 /// - ethflow specific invalidation conditions
 #[rustfmt::skip]
-const OPEN_ORDERS: &str = const_format::concatcp!(
-"SELECT * FROM ( ",
-    "SELECT ", SELECT,
-    " FROM ", FROM,
-    " LEFT OUTER JOIN ethflow_orders eth_o on eth_o.uid = o.uid ",
-    " WHERE o.valid_to >= $1",
-    " AND CASE WHEN eth_o.valid_to IS NULL THEN true ELSE eth_o.valid_to >= $1 END",
-r#") AS unfiltered
-WHERE
-    CASE kind
-        WHEN 'sell' THEN sum_sell < sell_amount
-        WHEN 'buy' THEN sum_buy < buy_amount
-    END AND
-    (NOT invalidated) AND
-    (onchain_placement_error IS NULL)
-"#
-);
+const OPEN_ORDERS: &str = r#"
+WITH live_orders AS (
+    SELECT o.*
+    FROM   orders o
+    LEFT   JOIN ethflow_orders e ON e.uid = o.uid
+    WHERE  o.cancellation_timestamp IS NULL
+      AND  o.valid_to >= $1
+      AND (e.valid_to IS NULL OR e.valid_to >= $1)
+      AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
+      AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
+      AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
+                                                                     AND op.placement_error IS NOT NULL)
+),
+trades_agg AS (
+     SELECT t.order_uid,
+            SUM(t.buy_amount) AS sum_buy,
+            SUM(t.sell_amount) AS sum_sell,
+            SUM(t.fee_amount) AS sum_fee
+     FROM trades t
+     JOIN live_orders lo ON lo.uid = t.order_uid
+     GROUP BY t.order_uid
+)
+SELECT
+    lo.uid,
+    lo.owner,
+    lo.creation_timestamp,
+    lo.sell_token,
+    lo.buy_token,
+    lo.sell_amount,
+    lo.buy_amount,
+    lo.valid_to,
+    lo.app_data,
+    lo.fee_amount,
+    lo.kind,
+    lo.partially_fillable,
+    lo.signature,
+    lo.receiver,
+    lo.signing_scheme,
+    lo.settlement_contract,
+    lo.sell_token_balance,
+    lo.buy_token_balance,
+    lo.class,
+
+    COALESCE(ta.sum_buy, 0) AS sum_buy,
+    COALESCE(ta.sum_sell, 0) AS sum_sell,
+    COALESCE(ta.sum_fee, 0) AS sum_fee,
+    false AS invalidated,
+    (lo.signing_scheme = 'presign' AND COALESCE(pe.unsigned, TRUE)) AS presignature_pending,
+    ARRAY(
+            SELECT (p.target, p.value, p.data)
+            FROM   interactions p
+            WHERE  p.order_uid = lo.uid AND p.execution = 'pre'
+            ORDER  BY p.index
+    ) AS pre_interactions,
+    ARRAY(
+            SELECT (p.target, p.value, p.data)
+            FROM   interactions p
+            WHERE  p.order_uid = lo.uid AND p.execution = 'post'
+            ORDER  BY p.index
+    ) AS post_interactions,
+    ed.ethflow_data,
+    opo.onchain_user,
+    NULL AS onchain_placement_error,
+    COALESCE(fee_agg.executed_fee,0)        AS executed_fee,
+    COALESCE(fee_agg.executed_fee_token, lo.sell_token) AS executed_fee_token,
+    ad.full_app_data
+FROM live_orders lo
+LEFT JOIN LATERAL (
+    SELECT NOT signed AS unsigned
+    FROM   presignature_events
+    WHERE  order_uid = lo.uid
+    ORDER  BY block_number DESC, log_index DESC
+    LIMIT  1
+    ) pe ON TRUE
+LEFT JOIN LATERAL (
+    SELECT sender AS onchain_user
+    FROM   onchain_placed_orders
+    WHERE  uid = lo.uid
+    ORDER  BY block_number DESC
+    LIMIT  1
+    ) opo ON TRUE
+LEFT JOIN LATERAL (
+    SELECT ROW(tx_hash, eo.valid_to) AS ethflow_data
+    FROM   ethflow_orders  eo
+    LEFT JOIN ethflow_refunds r ON r.order_uid = eo.uid
+    WHERE  eo.uid = lo.uid
+    ) ed ON TRUE
+LEFT JOIN LATERAL (
+    SELECT SUM(executed_fee) AS executed_fee,
+           (ARRAY_AGG(executed_fee_token))[1] AS executed_fee_token
+    FROM   order_execution
+    WHERE  order_uid = lo.uid
+) fee_agg ON TRUE
+LEFT JOIN app_data ad ON ad.contract_app_data = lo.app_data
+LEFT JOIN trades_agg ta ON  ta.order_uid = lo.uid
+WHERE ((lo.kind = 'sell' AND COALESCE(ta.sum_sell,0) < lo.sell_amount) OR
+       (lo.kind = 'buy'  AND COALESCE(ta.sum_buy ,0) < lo.buy_amount))
+"#;
 
 /// Uses the conditions from OPEN_ORDERS and checks the fok limit orders have
 /// surplus fee.
@@ -763,28 +844,6 @@ FROM settlements
     sqlx::query_scalar(QUERY).fetch_one(ex).await
 }
 
-/// Counts the number of limit orders with the conditions of OPEN_ORDERS. Used
-/// to enforce a maximum number of limit orders per user.
-#[instrument(skip_all)]
-pub async fn count_limit_orders_by_owner(
-    ex: &mut PgConnection,
-    min_valid_to: i64,
-    owner: &Address,
-) -> Result<i64, sqlx::Error> {
-    const QUERY: &str = const_format::concatcp!(
-        "SELECT COUNT (*) FROM (",
-        OPEN_ORDERS,
-        " AND class = 'limit'",
-        " AND owner = $2",
-        " ) AS subquery"
-    );
-    sqlx::query_scalar(QUERY)
-        .bind(min_valid_to)
-        .bind(owner)
-        .fetch_one(ex)
-        .await
-}
-
 #[derive(Debug, sqlx::FromRow)]
 pub struct OrderWithQuote {
     pub order_buy_amount: BigDecimal,
@@ -1616,6 +1675,18 @@ mod tests {
         assert!(!get_full_order(&mut db).await.unwrap().presignature_pending);
     }
 
+    #[tokio::test]
+    #[ignore]
+    async fn get_orders_with_quote() {
+        let mut db = PgConnection::connect("postgresql://").await.unwrap();
+        let mut db = db.begin().await.unwrap();
+        assert!(
+            user_orders_with_quote(&mut db, 0, &Default::default())
+                .await
+                .is_ok()
+        )
+    }
+
     #[tokio::test]
     #[ignore]
     async fn postgres_onchain_invalidated_orders() {