Drop CIP-20 data (cowprotocol#3771)

# Description
This PR drops the CIP-20 data, which has become obsolete.

# Changes

- [ ] univ2 test still uses this data to validate it is updated in some
way, since we don't have other test to cover that.
- [ ] Instead of using the CIP-20 structs, the queries migrated to
separate function.

## How to test
Updated existing tests.

Author: squadgazzz

crates/e2e/tests/e2e/database.rs

@@ -5,6 +5,7 @@ use {
     database::{Address, TransactionHash, byte_array::ByteArray, order_events},
     e2e::setup::Db,
     model::order::OrderUid,
+    sqlx::PgConnection,
     std::ops::DerefMut,
 };
 
@@ -41,57 +42,36 @@ pub struct AuctionTransaction {
     pub solution_uid: i64,
 }
 
-#[allow(dead_code)]
-#[derive(Clone, Debug)]
-pub struct Cip20Data {
-    pub txs: Vec<AuctionTransaction>,
-    pub participants: Vec<database::solver_competition_v2::AuctionParticipant>,
-    pub prices: Vec<database::auction_prices::AuctionPrice>,
-    pub reference_scores: Vec<database::reference_scores::Score>,
-    pub competition: serde_json::Value,
+pub async fn auction_participants(
+    ex: &mut PgConnection,
+    auction_id: i64,
+) -> anyhow::Result<Vec<Address>> {
+    const QUERY: &str = r#"
+        SELECT DISTINCT ps.solver
+        FROM proposed_solutions ps
+        WHERE ps.auction_id = $1
+    "#;
+    Ok(sqlx::query_as(QUERY).bind(auction_id).fetch_all(ex).await?)
 }
 
-/// Returns `Some(data)` if the all the expected CIP-20 data has been indexed
-/// for the most recent `auction_id` from `settlements` table.
-pub async fn most_recent_cip_20_data(db: &Db) -> Option<Cip20Data> {
-    let mut db = db.acquire().await.unwrap();
-
-    const LAST_AUCTION_ID: &str = "SELECT auction_id FROM settlements WHERE auction_id IS NOT \
-                                   NULL ORDER BY auction_id DESC LIMIT 1";
-    let auction_id: i64 = sqlx::query_scalar(LAST_AUCTION_ID)
-        .fetch_optional(db.deref_mut())
-        .await
-        .unwrap()?;
-
-    const TX_QUERY: &str = r"
-SELECT * FROM settlements WHERE auction_id = $1";
-
-    let txs: Vec<AuctionTransaction> = sqlx::query_as(TX_QUERY)
-        .bind(auction_id)
-        .fetch_all(db.deref_mut())
-        .await
-        .ok()?;
+pub async fn auction_prices(
+    ex: &mut PgConnection,
+    auction_id: i64,
+) -> anyhow::Result<Vec<database::auction_prices::AuctionPrice>> {
+    const QUERY: &str = "SELECT * FROM auction_prices WHERE auction_id = $1";
+    Ok(sqlx::query_as(QUERY).bind(auction_id).fetch_all(ex).await?)
+}
 
-    let participants =
-        database::solver_competition_v2::fetch_auction_participants(&mut db, auction_id)
-            .await
-            .unwrap();
-    let prices = database::auction_prices::fetch(&mut db, auction_id)
-        .await
-        .unwrap();
-    let reference_scores = database::reference_scores::fetch(&mut db, auction_id)
-        .await
-        .unwrap();
-    let competition = database::solver_competition::load_by_id(&mut db, auction_id)
-        .await
-        .unwrap()?
-        .json;
+pub async fn reference_scores(
+    ex: &mut PgConnection,
+    auction_id: i64,
+) -> anyhow::Result<Vec<database::reference_scores::Score>> {
+    const QUERY: &str = "SELECT * FROM reference_scores WHERE auction_id = $1";
+    Ok(sqlx::query_as(QUERY).bind(auction_id).fetch_all(ex).await?)
+}
 
-    Some(Cip20Data {
-        txs,
-        participants,
-        prices,
-        reference_scores,
-        competition,
-    })
+pub async fn latest_auction_id(ex: &mut PgConnection) -> anyhow::Result<Option<i64>> {
+    const QUERY: &str = "SELECT auction_id FROM settlements WHERE auction_id IS NOT NULL ORDER BY \
+                         auction_id DESC LIMIT 1";
+    Ok(sqlx::query_scalar(QUERY).fetch_optional(ex).await?)
 }

crates/e2e/tests/e2e/univ2.rs

@@ -126,24 +126,30 @@ async fn test(web3: Web3) {
         .await
         .unwrap();
 
-    let cip_20_data_updated = || async {
-        onchain.mint_block().await;
-        let data = match crate::database::most_recent_cip_20_data(services.db()).await {
-            Some(data) => data,
-            None => return false,
+    let data_updated = || async {
+        let mut db = services.db().acquire().await.unwrap();
+        let Some(auction_id) = crate::database::latest_auction_id(&mut db).await.unwrap() else {
+            return false;
         };
 
+        let participants = crate::database::auction_participants(&mut db, auction_id)
+            .await
+            .unwrap();
+        let prices = crate::database::auction_prices(&mut db, auction_id)
+            .await
+            .unwrap();
+        let scores = crate::database::reference_scores(&mut db, auction_id)
+            .await
+            .unwrap();
         // sell and buy token price can be found
-        data.prices.iter().any(|p| p.token.0 == onchain.contracts().weth.address().0)
-            && data.prices.iter().any(|p| p.token.0 == token.address().0)
+        prices.iter().any(|p| p.token.0 == onchain.contracts().weth.address().0)
+            && prices.iter().any(|p| p.token.0 == token.address().0)
             // solver participated in the competition
-            && data.participants.iter().any(|p| p.participant.0 == solver.address().0)
+            && participants.iter().any(|p| p.0 == solver.address().0)
             // and won the auction
-            && data.reference_scores.first().is_some_and(|score| score.solver.0 == solver.address().0)
+            && scores.first().is_some_and(|score| score.solver.0 == solver.address().0)
     };
-    wait_for_condition(TIMEOUT, cip_20_data_updated)
-        .await
-        .unwrap();
+    wait_for_condition(TIMEOUT, data_updated).await.unwrap();
 }
 
 fn order_events_matching_fuzzy(actual: &[OrderEvent], expected: &[OrderEventLabel]) -> bool {