Remove obsolete solver competition data (#2143)

# Description Now that we collect all the competition data we care about going forward, we can remove the obsolete fields. Changes should be backwards compatible as `Options` will be parsed as Some if present and extra fields that remain in the json that is stored in the DB will be ignored. Very old auctions for which we don't store ranking or score will fail to load (but that's acceptable IMO) # Changes - [ ] Make it so that we don't log calldata fields that don't exist for non-winners. - [ ] Remove objective as it's not recorded for runners up (and isn't really relevant just for the winner). All we care about now is score - [ ] Remove gasPrice and liquidityFetchedBlock as they don't exist anymore. - [ ] Make mandatory score and ranking non-optional - [ ] Add e2e test for multiple solver solutions ## How to test Run e2e test ## Related Issues Fixes #1949
cowprotocol · Dec 18, 2023 · a5e3ff5 · a5e3ff5
1 parent 79ae63c
commit a5e3ff5
Show file tree

Hide file tree

Showing 17 changed files with 291 additions and 272 deletions.
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
@@ -238,8 +238,8 @@ impl RunLoop {
                         let mut settlement = SolverSettlement {
                             solver: participant.driver.name.clone(),
                             solver_address: participant.solution.account,
-                            score: Some(Score::Solver(participant.solution.score.get())),
-                            ranking: Some(solutions.len() - index),
+                            score: Score::Solver(participant.solution.score.get()),
+                            ranking: solutions.len() - index,
                             orders: participant
                                 .solution
                                 .orders()
@@ -256,21 +256,17 @@ impl RunLoop {
                                 .iter()
                                 .map(|(token, price)| (*token, *price))
                                 .collect(),
-                            // TODO: revisit once colocation is enabled (remove not populated
-                            // fields) Not all fields can be populated in the colocated world
-                            ..Default::default()
+                            call_data: None,
+                            uninternalized_call_data: None,
                         };
                         if is_winner {
-                            settlement.call_data = revealed.calldata.internalized.clone();
+                            settlement.call_data = Some(revealed.calldata.internalized.clone());
                             settlement.uninternalized_call_data =
                                 Some(revealed.calldata.uninternalized.clone());
                         }
                         settlement
                     })
                     .collect(),
-                // TODO: revisit once colocation is enabled (remove not populated fields)
-                // Not all fields can be populated in the colocated world
-                ..Default::default()
             };
             let competition = Competition {
                 auction_id,

diff --git a/crates/e2e/src/setup/colocation.rs b/crates/e2e/src/setup/colocation.rs
@@ -18,6 +18,7 @@ risk-parameters = [0,0,0,0]
     ));
     let args = vec![
         "solvers".to_string(),
+        format!("--addr=0.0.0.0:0"),
         "baseline".to_string(),
         format!("--config={}", config_file.display()),
     ];
@@ -32,22 +33,43 @@ risk-parameters = [0,0,0,0]
     format!("http://{solver_addr}").parse().unwrap()
 }
 
-pub fn start_driver(
-    contracts: &Contracts,
-    solver_endpoint: &Url,
-    solver_account: &TestAccount,
-) -> JoinHandle<()> {
+pub struct SolverEngine {
+    pub name: String,
+    pub endpoint: Url,
+    pub account: TestAccount,
+}
+
+pub fn start_driver(contracts: &Contracts, solvers: Vec<SolverEngine>) -> JoinHandle<()> {
+    let solvers = solvers
+        .iter()
+        .map(
+            |SolverEngine {
+                 name,
+                 account,
+                 endpoint,
+             }| {
+                let account = hex::encode(account.private_key());
+                format!(
+                    r#"
+[[solver]]
+name = "{name}"
+endpoint = "{endpoint}"
+relative-slippage = "0.1"
+account = "{account}"
+
+"#
+                )
+            },
+        )
+        .collect::<Vec<String>>()
+        .join("\n");
     let config_file = config_tmp_file(format!(
         r#"
 [contracts]
 gp-v2-settlement = "{:?}"
 weth = "{:?}"
 
-[[solver]]
-name = "test_solver"
-endpoint = "{solver_endpoint}"
-relative-slippage = "0.1"
-account = "0x{}"
+{solvers}
 
 [liquidity]
 base-tokens = []
@@ -66,7 +88,6 @@ mempool = "public"
 "#,
         contracts.gp_settlement.address(),
         contracts.weth.address(),
-        hex::encode(solver_account.private_key()),
         contracts.uniswap_v2_router.address(),
         H256(UNISWAP_INIT),
     ));

diff --git a/crates/e2e/tests/e2e/colocation_buffers.rs b/crates/e2e/tests/e2e/colocation_buffers.rs
@@ -1,5 +1,8 @@
 use {
-    e2e::{setup::*, tx},
+    e2e::{
+        setup::{colocation::SolverEngine, *},
+        tx,
+    },
     ethcontract::prelude::U256,
     model::{
         order::{OrderCreation, OrderKind},
@@ -41,8 +44,14 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
 
     // Start system
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
-
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![
         "--enable-colocation=true".to_string(),

diff --git a/crates/e2e/tests/e2e/colocation_eth_safe.rs b/crates/e2e/tests/e2e/colocation_eth_safe.rs
@@ -1,6 +1,6 @@
 use {
     e2e::{
-        setup::{safe::Safe, *},
+        setup::{colocation::SolverEngine, safe::Safe, *},
         tx,
     },
     ethcontract::U256,
@@ -38,7 +38,14 @@ async fn test(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![

diff --git a/crates/e2e/tests/e2e/colocation_ethflow.rs b/crates/e2e/tests/e2e/colocation_ethflow.rs
@@ -2,7 +2,7 @@ use {
     crate::ethflow::{EthFlowOrderOnchainStatus, EthFlowTradeIntent, ExtendedEthFlowOrder},
     autopilot::database::onchain_order_events::ethflow_events::WRAP_ALL_SELECTOR,
     contracts::ERC20Mintable,
-    e2e::setup::*,
+    e2e::setup::{colocation::SolverEngine, *},
     ethcontract::{Account, H160, U256},
     ethrpc::{current_block::timestamp_of_current_block_in_seconds, Web3},
     model::{
@@ -43,7 +43,14 @@ async fn eth_flow_tx(web3: Web3) {
     };
 
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![

diff --git a/crates/e2e/tests/e2e/colocation_hooks.rs b/crates/e2e/tests/e2e/colocation_hooks.rs
@@ -1,7 +1,7 @@
 use {
     contracts::GnosisSafe,
     e2e::{
-        setup::{safe::Safe, *},
+        setup::{colocation::SolverEngine, safe::Safe, *},
         tx,
         tx_value,
     },
@@ -70,7 +70,14 @@ async fn allowance(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![
@@ -248,7 +255,14 @@ async fn signature(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![
@@ -355,7 +369,14 @@ async fn partial_fills(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![

diff --git a/crates/e2e/tests/e2e/colocation_partial_fill.rs b/crates/e2e/tests/e2e/colocation_partial_fill.rs
@@ -1,5 +1,9 @@
 use {
-    e2e::{setup::*, tx, tx_value},
+    e2e::{
+        setup::{colocation::SolverEngine, *},
+        tx,
+        tx_value,
+    },
     ethcontract::U256,
     model::{
         order::{LimitOrderClass, OrderClass, OrderCreation, OrderKind},
@@ -42,7 +46,14 @@ async fn test(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![

diff --git a/crates/e2e/tests/e2e/colocation_quoting.rs b/crates/e2e/tests/e2e/colocation_quoting.rs
@@ -1,5 +1,9 @@
 use {
-    e2e::{setup::*, tx, tx_value},
+    e2e::{
+        setup::{colocation::SolverEngine, *},
+        tx,
+        tx_value,
+    },
     ethcontract::U256,
     model::quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
     number::nonzero::U256 as NonZeroU256,
@@ -37,7 +41,14 @@ async fn uses_stale_liquidity(web3: Web3) {
 
     tracing::info!("Starting services.");
     let solver_endpoint = colocation::start_solver(onchain.contracts().weth.address()).await;
-    colocation::start_driver(onchain.contracts(), &solver_endpoint, &solver);
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![SolverEngine {
+            name: "test_solver".into(),
+            account: solver,
+            endpoint: solver_endpoint,
+        }],
+    );
 
     let services = Services::new(onchain.contracts()).await;
     services.start_autopilot(vec![