Remove obsolete solver competition data

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,

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),
     ));

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(),

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![

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![

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![

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![

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![